Merge commit 'v2.6.28-rc2' into x86/pci-ioapic-boot-irq-quirks

38 files changed, 4580 insertions, 2152 deletions

diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
index 00ff53348491..6de1e0ffd391 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -57,6 +57,16 @@ config SENSORS_ABITUGURU3
           This driver can also be built as a module.  If so, the module
           will be called abituguru3.
 
+config SENSORS_AD7414
+        tristate "Analog Devices AD7414"
+        depends on I2C && EXPERIMENTAL
+        help
+          If you say yes here you get support for the Analog Devices
+          AD7414 temperature monitoring chip.
+
+          This driver can also be built as a module. If so, the module
+          will be called ad7414.
+
 config SENSORS_AD7418
         tristate "Analog Devices AD7416, AD7417 and AD7418"
         depends on I2C && EXPERIMENTAL
@@ -67,6 +77,22 @@ config SENSORS_AD7418
           This driver can also be built as a module. If so, the module
           will be called ad7418.
 
+config SENSORS_ADCXX
+        tristate "National Semiconductor ADCxxxSxxx"
+        depends on SPI_MASTER && EXPERIMENTAL
+        help
+          If you say yes here you get support for the National Semiconductor
+          ADC<bb><c>S<sss> chip family, where
+          * bb  is the resolution in number of bits (8, 10, 12)
+          * c   is the number of channels (1, 2, 4, 8)
+          * sss is the maximum conversion speed (021 for 200 kSPS, 051 for 500
+            kSPS and 101 for 1 MSPS)
+
+          Examples : ADC081S101, ADC124S501, ...
+
+          This driver can also be built as a module.  If so, the module
+          will be called adcxx.
+
 config SENSORS_ADM1021
         tristate "Analog Devices ADM1021 and compatibles"
         depends on I2C
@@ -124,7 +150,7 @@ config SENSORS_ADM1031
 
 config SENSORS_ADM9240
         tristate "Analog Devices ADM9240 and compatibles"
-        depends on I2C && EXPERIMENTAL
+        depends on I2C
         select HWMON_VID
         help
           If you say yes here you get support for Analog Devices ADM9240,
@@ -394,13 +420,24 @@ config SENSORS_LM75
         tristate "National Semiconductor LM75 and compatibles"
         depends on I2C
         help
-          If you say yes here you get support for National Semiconductor LM75
-          sensor chips and clones: Dallas Semiconductor DS75 and DS1775 (in
-          9-bit precision mode), and TelCom (now Microchip) TCN75.
+          If you say yes here you get support for one common type of
+          temperature sensor chip, with models including:
 
-          The DS75 and DS1775 in 10- to 12-bit precision modes will require
-          a force module parameter. The driver will not handle the extra
-          precision anyhow.
+                - Dallas Semiconductor DS75 and DS1775
+                - Maxim MAX6625 and MAX6626
+                - Microchip MCP980x
+                - National Semiconductor LM75
+                - NXP's LM75A
+                - ST Microelectronics STDS75
+                - TelCom (now Microchip) TCN75
+                - Texas Instruments TMP100, TMP101, TMP75, TMP175, TMP275
+
+          This driver supports driver model based binding through board
+          specific I2C device tables.
+
+          It also supports the "legacy" style of driver binding.  To use
+          that with some chips which don't replicate LM75 quirks exactly,
+          you may need the "force" module parameter.
 
           This driver can also be built as a module.  If so, the module
           will be called lm75.
@@ -473,11 +510,9 @@ config SENSORS_LM90
         depends on I2C
         help
           If you say yes here you get support for National Semiconductor LM90,
-          LM86, LM89 and LM99, Analog Devices ADM1032 and Maxim MAX6657,
-          MAX6658, MAX6659, MAX6680 and MAX6681 sensor chips.
-
-          The Analog Devices ADT7461 sensor chip is also supported, but only
-          if found in ADM1032 compatibility mode.
+          LM86, LM89 and LM99, Analog Devices ADM1032 and ADT7461, and Maxim
+          MAX6646, MAX6647, MAX6649, MAX6657, MAX6658, MAX6659, MAX6680 and
+          MAX6681 sensor chips.
 
           This driver can also be built as a module.  If so, the module
           will be called lm90.
@@ -503,6 +538,15 @@ config SENSORS_LM93
           This driver can also be built as a module.  If so, the module
           will be called lm93.
 
+config SENSORS_MAX1111
+        tristate "Maxim MAX1111 Multichannel, Serial 8-bit ADC chip"
+        depends on SPI_MASTER
+        help
+          Say y here to support Maxim's MAX1111 ADC chips.
+
+          This driver can also be built as a module.  If so, the module
+          will be called max1111.
+
 config SENSORS_MAX1619
         tristate "Maxim MAX1619 sensor chip"
         depends on I2C
@@ -564,8 +608,8 @@ config SENSORS_DME1737
         select HWMON_VID
         help
           If you say yes here you get support for the hardware monitoring
-          and fan control features of the SMSC DME1737 (and compatibles
-          like the Asus A8000) and SCH311x Super-I/O chips.
+          and fan control features of the SMSC DME1737, SCH311x, SCH5027, and
+          Asus A8000 Super-I/O chips.
 
           This driver can also be built as a module.  If so, the module
           will be called dme1737.
@@ -754,6 +798,13 @@ config SENSORS_W83627EHF
           This driver can also be built as a module.  If so, the module
           will be called w83627ehf.
 
+config SENSORS_ULTRA45
+        tristate "Sun Ultra45 PIC16F747"
+        depends on SPARC64
+        help
+          This driver provides support for the Ultra45 workstation environmental
+          sensors.
+
 config SENSORS_HDAPS
         tristate "IBM Hard Drive Active Protection System (hdaps)"
         depends on INPUT && X86
diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
index d098677e08de..042d5a78622e 100644
--- a/drivers/hwmon/Makefile
+++ b/drivers/hwmon/Makefile
@@ -15,7 +15,9 @@ obj-$(CONFIG_SENSORS_W83791D)	+= w83791d.o
 
 obj-$(CONFIG_SENSORS_ABITUGURU) += abituguru.o
 obj-$(CONFIG_SENSORS_ABITUGURU3)+= abituguru3.o
+obj-$(CONFIG_SENSORS_AD7414)    += ad7414.o
 obj-$(CONFIG_SENSORS_AD7418)    += ad7418.o
+obj-$(CONFIG_SENSORS_ADCXX)     += adcxx.o
 obj-$(CONFIG_SENSORS_ADM1021)   += adm1021.o
 obj-$(CONFIG_SENSORS_ADM1025)   += adm1025.o
 obj-$(CONFIG_SENSORS_ADM1026)   += adm1026.o
@@ -39,6 +41,7 @@ obj-$(CONFIG_SENSORS_FSCHMD)	+= fschmd.o
 obj-$(CONFIG_SENSORS_FSCPOS)    += fscpos.o
 obj-$(CONFIG_SENSORS_GL518SM)   += gl518sm.o
 obj-$(CONFIG_SENSORS_GL520SM)   += gl520sm.o
+obj-$(CONFIG_SENSORS_ULTRA45)   += ultra45_env.o
 obj-$(CONFIG_SENSORS_HDAPS)     += hdaps.o
 obj-$(CONFIG_SENSORS_I5K_AMB)   += i5k_amb.o
 obj-$(CONFIG_SENSORS_IBMAEM)    += ibmaem.o
@@ -57,6 +60,7 @@ obj-$(CONFIG_SENSORS_LM87)	+= lm87.o
 obj-$(CONFIG_SENSORS_LM90)      += lm90.o
 obj-$(CONFIG_SENSORS_LM92)      += lm92.o
 obj-$(CONFIG_SENSORS_LM93)      += lm93.o
+obj-$(CONFIG_SENSORS_MAX1111)   += max1111.o
 obj-$(CONFIG_SENSORS_MAX1619)   += max1619.o
 obj-$(CONFIG_SENSORS_MAX6650)   += max6650.o
 obj-$(CONFIG_SENSORS_PC87360)   += pc87360.o
diff --git a/drivers/hwmon/abituguru3.c b/drivers/hwmon/abituguru3.c
index f00f497b9ca9..70bb854086df 100644
--- a/drivers/hwmon/abituguru3.c
+++ b/drivers/hwmon/abituguru3.c
@@ -1,5 +1,8 @@
 /*
-    abituguru3.c Copyright (c) 2006 Hans de Goede <j.w.r.degoede@hhs.nl>
+    abituguru3.c
+
+    Copyright (c) 2006-2008 Hans de Goede <j.w.r.degoede@hhs.nl>
+    Copyright (c) 2008 Alistair John Strachan <alistair@devzero.co.uk>
 
     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
@@ -116,7 +119,7 @@ struct abituguru3_sensor_info {
 
 struct abituguru3_motherboard_info {
         u16 id;
-        const char *name;
+        const char *dmi_name;
         /* + 1 -> end of sensors indicated by a sensor with name == NULL */
         struct abituguru3_sensor_info sensors[ABIT_UGURU3_MAX_NO_SENSORS + 1];
 };
@@ -161,7 +164,7 @@ struct abituguru3_data {
 
 /* Constants */
 static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
-        { 0x000C, "unknown", {
+        { 0x000C, NULL /* Unknown, need DMI string */, {
                 { "CPU Core",            0, 0, 10, 1, 0 },
                 { "DDR",                 1, 0, 10, 1, 0 },
                 { "DDR VTT",             2, 0, 10, 1, 0 },
@@ -175,7 +178,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "+3.3V",              10, 0, 20, 1, 0 },
                 { "5VSB",               11, 0, 30, 1, 0 },
                 { "CPU",                24, 1, 1, 1, 0 },
-                { "System ",            25, 1, 1, 1, 0 },
+                { "System",             25, 1, 1, 1, 0 },
                 { "PWM",                26, 1, 1, 1, 0 },
                 { "CPU Fan",            32, 2, 60, 1, 0 },
                 { "NB Fan",             33, 2, 60, 1, 0 },
@@ -183,7 +186,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "AUX1 Fan",           35, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x000D, "Abit AW8", {
+        { 0x000D, NULL /* Abit AW8, need DMI string */, {
                 { "CPU Core",            0, 0, 10, 1, 0 },
                 { "DDR",                 1, 0, 10, 1, 0 },
                 { "DDR VTT",             2, 0, 10, 1, 0 },
@@ -197,7 +200,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "+3.3V",              10, 0, 20, 1, 0 },
                 { "5VSB",               11, 0, 30, 1, 0 },
                 { "CPU",                24, 1, 1, 1, 0 },
-                { "System ",            25, 1, 1, 1, 0 },
+                { "System",             25, 1, 1, 1, 0 },
                 { "PWM1",               26, 1, 1, 1, 0 },
                 { "PWM2",               27, 1, 1, 1, 0 },
                 { "PWM3",               28, 1, 1, 1, 0 },
@@ -212,7 +215,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "AUX5 Fan",           39, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x000E, "AL-8", {
+        { 0x000E, NULL /* AL-8, need DMI string */, {
                 { "CPU Core",            0, 0, 10, 1, 0 },
                 { "DDR",                 1, 0, 10, 1, 0 },
                 { "DDR VTT",             2, 0, 10, 1, 0 },
@@ -226,14 +229,14 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "+3.3V",              10, 0, 20, 1, 0 },
                 { "5VSB",               11, 0, 30, 1, 0 },
                 { "CPU",                24, 1, 1, 1, 0 },
-                { "System ",            25, 1, 1, 1, 0 },
+                { "System",             25, 1, 1, 1, 0 },
                 { "PWM",                26, 1, 1, 1, 0 },
                 { "CPU Fan",            32, 2, 60, 1, 0 },
                 { "NB Fan",             33, 2, 60, 1, 0 },
                 { "SYS Fan",            34, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x000F, "unknown", {
+        { 0x000F, NULL /* Unknown, need DMI string */, {
                 { "CPU Core",            0, 0, 10, 1, 0 },
                 { "DDR",                 1, 0, 10, 1, 0 },
                 { "DDR VTT",             2, 0, 10, 1, 0 },
@@ -247,14 +250,14 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "+3.3V",              10, 0, 20, 1, 0 },
                 { "5VSB",               11, 0, 30, 1, 0 },
                 { "CPU",                24, 1, 1, 1, 0 },
-                { "System ",            25, 1, 1, 1, 0 },
+                { "System",             25, 1, 1, 1, 0 },
                 { "PWM",                26, 1, 1, 1, 0 },
                 { "CPU Fan",            32, 2, 60, 1, 0 },
                 { "NB Fan",             33, 2, 60, 1, 0 },
                 { "SYS Fan",            34, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x0010, "Abit NI8 SLI GR", {
+        { 0x0010, NULL /* Abit NI8 SLI GR, need DMI string */, {
                 { "CPU Core",            0, 0, 10, 1, 0 },
                 { "DDR",                 1, 0, 10, 1, 0 },
                 { "DDR VTT",             2, 0, 10, 1, 0 },
@@ -276,7 +279,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "OTES1 Fan",          36, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x0011, "Abit AT8 32X", {
+        { 0x0011, "AT8 32X(ATI RD580-ULI M1575)", {
                 { "CPU Core",            0, 0, 10, 1, 0 },
                 { "DDR",                 1, 0, 20, 1, 0 },
                 { "DDR VTT",             2, 0, 10, 1, 0 },
@@ -300,9 +303,10 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "SYS Fan",            34, 2, 60, 1, 0 },
                 { "AUX1 Fan",           35, 2, 60, 1, 0 },
                 { "AUX2 Fan",           36, 2, 60, 1, 0 },
+                { "AUX3 Fan",           37, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x0012, "Abit AN8 32X", {
+        { 0x0012, NULL /* Abit AN8 32X, need DMI string */, {
                 { "CPU Core",            0, 0, 10, 1, 0 },
                 { "DDR",                 1, 0, 20, 1, 0 },
                 { "DDR VTT",             2, 0, 10, 1, 0 },
@@ -324,7 +328,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "AUX1 Fan",           36, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x0013, "Abit AW8D", {
+        { 0x0013, NULL /* Abit AW8D, need DMI string */, {
                 { "CPU Core",            0, 0, 10, 1, 0 },
                 { "DDR",                 1, 0, 10, 1, 0 },
                 { "DDR VTT",             2, 0, 10, 1, 0 },
@@ -338,7 +342,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "+3.3V",              10, 0, 20, 1, 0 },
                 { "5VSB",               11, 0, 30, 1, 0 },
                 { "CPU",                24, 1, 1, 1, 0 },
-                { "System ",            25, 1, 1, 1, 0 },
+                { "System",             25, 1, 1, 1, 0 },
                 { "PWM1",               26, 1, 1, 1, 0 },
                 { "PWM2",               27, 1, 1, 1, 0 },
                 { "PWM3",               28, 1, 1, 1, 0 },
@@ -353,7 +357,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "AUX5 Fan",           39, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x0014, "Abit AB9 Pro", {
+        { 0x0014, NULL /* Abit AB9 Pro, need DMI string */, {
                 { "CPU Core",            0, 0, 10, 1, 0 },
                 { "DDR",                 1, 0, 10, 1, 0 },
                 { "DDR VTT",             2, 0, 10, 1, 0 },
@@ -367,14 +371,14 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "+3.3V",              10, 0, 20, 1, 0 },
                 { "5VSB",               11, 0, 30, 1, 0 },
                 { "CPU",                24, 1, 1, 1, 0 },
-                { "System ",            25, 1, 1, 1, 0 },
+                { "System",             25, 1, 1, 1, 0 },
                 { "PWM",                26, 1, 1, 1, 0 },
                 { "CPU Fan",            32, 2, 60, 1, 0 },
                 { "NB Fan",             33, 2, 60, 1, 0 },
                 { "SYS Fan",            34, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x0015, "unknown", {
+        { 0x0015, NULL /* Unknown, need DMI string */, {
                 { "CPU Core",            0, 0, 10, 1, 0 },
                 { "DDR",                 1, 0, 20, 1, 0 },
                 { "DDR VTT",             2, 0, 10, 1, 0 },
@@ -398,7 +402,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "AUX3 Fan",           36, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x0016, "AW9D-MAX", {
+        { 0x0016, "AW9D-MAX       (Intel i975-ICH7)", {
                 { "CPU Core",            0, 0, 10, 1, 0 },
                 { "DDR2",                1, 0, 20, 1, 0 },
                 { "DDR2 VTT",            2, 0, 10, 1, 0 },
@@ -412,7 +416,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "+3.3V",              10, 0, 20, 1, 0 },
                 { "5VSB",               11, 0, 30, 1, 0 },
                 { "CPU",                24, 1, 1, 1, 0 },
-                { "System ",            25, 1, 1, 1, 0 },
+                { "System",             25, 1, 1, 1, 0 },
                 { "PWM1",               26, 1, 1, 1, 0 },
                 { "PWM2",               27, 1, 1, 1, 0 },
                 { "PWM3",               28, 1, 1, 1, 0 },
@@ -426,7 +430,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "OTES1 Fan",          38, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x0017, "unknown", {
+        { 0x0017, NULL /* Unknown, need DMI string */, {
                 { "CPU Core",            0, 0, 10, 1, 0 },
                 { "DDR2",                1, 0, 20, 1, 0 },
                 { "DDR2 VTT",            2, 0, 10, 1, 0 },
@@ -442,7 +446,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "ATX +3.3V",          10, 0, 20, 1, 0 },
                 { "ATX 5VSB",           11, 0, 30, 1, 0 },
                 { "CPU",                24, 1, 1, 1, 0 },
-                { "System ",            26, 1, 1, 1, 0 },
+                { "System",             26, 1, 1, 1, 0 },
                 { "PWM",                27, 1, 1, 1, 0 },
                 { "CPU FAN",            32, 2, 60, 1, 0 },
                 { "SYS FAN",            34, 2, 60, 1, 0 },
@@ -451,7 +455,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "AUX3 FAN",           37, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x0018, "unknown", {
+        { 0x0018, NULL /* Unknown, need DMI string */, {
                 { "CPU Core",            0, 0, 10, 1, 0 },
                 { "DDR2",                1, 0, 20, 1, 0 },
                 { "DDR2 VTT",            2, 0, 10, 1, 0 },
@@ -465,7 +469,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "+3.3V",              10, 0, 20, 1, 0 },
                 { "5VSB",               11, 0, 30, 1, 0 },
                 { "CPU",                24, 1, 1, 1, 0 },
-                { "System ",            25, 1, 1, 1, 0 },
+                { "System",             25, 1, 1, 1, 0 },
                 { "PWM Phase1",         26, 1, 1, 1, 0 },
                 { "PWM Phase2",         27, 1, 1, 1, 0 },
                 { "PWM Phase3",         28, 1, 1, 1, 0 },
@@ -478,12 +482,12 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "AUX3 Fan",           36, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x0019, "unknown", {
+        { 0x0019, NULL /* Unknown, need DMI string */, {
                 { "CPU Core",            7, 0, 10, 1, 0 },
                 { "DDR2",               13, 0, 20, 1, 0 },
                 { "DDR2 VTT",           14, 0, 10, 1, 0 },
                 { "CPU VTT",             3, 0, 20, 1, 0 },
-                { "NB 1.2V ",            4, 0, 10, 1, 0 },
+                { "NB 1.2V",             4, 0, 10, 1, 0 },
                 { "SB 1.5V",             6, 0, 10, 1, 0 },
                 { "HyperTransport",      5, 0, 10, 1, 0 },
                 { "ATX +12V (24-Pin)",  12, 0, 60, 1, 0 },
@@ -492,7 +496,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "ATX +3.3V",          10, 0, 20, 1, 0 },
                 { "ATX 5VSB",           11, 0, 30, 1, 0 },
                 { "CPU",                24, 1, 1, 1, 0 },
-                { "System ",            25, 1, 1, 1, 0 },
+                { "System",             25, 1, 1, 1, 0 },
                 { "PWM Phase1",         26, 1, 1, 1, 0 },
                 { "PWM Phase2",         27, 1, 1, 1, 0 },
                 { "PWM Phase3",         28, 1, 1, 1, 0 },
@@ -505,7 +509,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "AUX3 FAN",           36, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x001A, "Abit IP35 Pro", {
+        { 0x001A, "IP35 Pro(Intel P35-ICH9R)", {
                 { "CPU Core",            0, 0, 10, 1, 0 },
                 { "DDR2",                1, 0, 20, 1, 0 },
                 { "DDR2 VTT",            2, 0, 10, 1, 0 },
@@ -519,8 +523,8 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "+3.3V",              10, 0, 20, 1, 0 },
                 { "5VSB",               11, 0, 30, 1, 0 },
                 { "CPU",                24, 1, 1, 1, 0 },
-                { "System ",            25, 1, 1, 1, 0 },
-                { "PWM ",               26, 1, 1, 1, 0 },
+                { "System",             25, 1, 1, 1, 0 },
+                { "PWM",                26, 1, 1, 1, 0 },
                 { "PWM Phase2",         27, 1, 1, 1, 0 },
                 { "PWM Phase3",         28, 1, 1, 1, 0 },
                 { "PWM Phase4",         29, 1, 1, 1, 0 },
@@ -533,7 +537,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "AUX4 Fan",           37, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x001B, "unknown", {
+        { 0x001B, NULL /* Unknown, need DMI string */, {
                 { "CPU Core",            0, 0, 10, 1, 0 },
                 { "DDR3",                1, 0, 20, 1, 0 },
                 { "DDR3 VTT",            2, 0, 10, 1, 0 },
@@ -560,7 +564,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "AUX3 Fan",           36, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x001C, "unknown", {
+        { 0x001C, NULL /* Unknown, need DMI string */, {
                 { "CPU Core",            0, 0, 10, 1, 0 },
                 { "DDR2",                1, 0, 20, 1, 0 },
                 { "DDR2 VTT",            2, 0, 10, 1, 0 },
@@ -935,9 +939,18 @@ static int __devinit abituguru3_probe(struct platform_device *pdev)
                 goto abituguru3_probe_error;
         }
         data->sensors = abituguru3_motherboards[i].sensors;
+
         printk(KERN_INFO ABIT_UGURU3_NAME ": found Abit uGuru3, motherboard "
-                "ID: %04X (%s)\n", (unsigned int)id,
-                abituguru3_motherboards[i].name);
+                "ID: %04X\n", (unsigned int)id);
+
+#ifdef CONFIG_DMI
+        if (!abituguru3_motherboards[i].dmi_name) {
+                printk(KERN_WARNING ABIT_UGURU3_NAME ": this motherboard was "
+                        "not detected using DMI. Please send the output of "
+                        "\"dmidecode\" to the abituguru3 maintainer "
+                        "(see MAINTAINERS)\n");
+        }
+#endif
 
         /* Fill the sysfs attr array */
         sysfs_attr_i = 0;
@@ -1109,6 +1122,46 @@ static struct platform_driver abituguru3_driver = {
         .resume = abituguru3_resume
 };
 
+#ifdef CONFIG_DMI
+
+static int __init abituguru3_dmi_detect(void)
+{
+        const char *board_vendor, *board_name;
+        int i, err = (force) ? 1 : -ENODEV;
+
+        board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
+        if (!board_vendor || strcmp(board_vendor, "http://www.abit.com.tw/"))
+                return err;
+
+        board_name = dmi_get_system_info(DMI_BOARD_NAME);
+        if (!board_name)
+                return err;
+
+        for (i = 0; abituguru3_motherboards[i].id; i++) {
+                const char *dmi_name = abituguru3_motherboards[i].dmi_name;
+                if (dmi_name && !strcmp(dmi_name, board_name))
+                        break;
+        }
+
+        if (!abituguru3_motherboards[i].id)
+                return 1;
+
+        return 0;
+}
+
+#else /* !CONFIG_DMI */
+
+static inline int abituguru3_dmi_detect(void)
+{
+        return -ENODEV;
+}
+
+#endif /* CONFIG_DMI */
+
+/* FIXME: Manual detection should die eventually; we need to collect stable
+ *        DMI model names first before we can rely entirely on CONFIG_DMI.
+ */
+
 static int __init abituguru3_detect(void)
 {
         /* See if there is an uguru3 there. An idle uGuru3 will hold 0x00 or
@@ -1119,7 +1172,7 @@ static int __init abituguru3_detect(void)
         if (((data_val == 0x00) || (data_val == 0x08)) &&
                         ((cmd_val == 0xAC) || (cmd_val == 0x05) ||
                          (cmd_val == 0x55)))
-                return ABIT_UGURU3_BASE;
+                return 0;
 
         ABIT_UGURU3_DEBUG("no Abit uGuru3 found, data = 0x%02X, cmd = "
                 "0x%02X\n", (unsigned int)data_val, (unsigned int)cmd_val);
@@ -1127,7 +1180,7 @@ static int __init abituguru3_detect(void)
         if (force) {
                 printk(KERN_INFO ABIT_UGURU3_NAME ": Assuming Abit uGuru3 is "
                                 "present because of \"force\" parameter\n");
-                return ABIT_UGURU3_BASE;
+                return 0;
         }
 
         /* No uGuru3 found */
@@ -1138,27 +1191,29 @@ static struct platform_device *abituguru3_pdev;
 
 static int __init abituguru3_init(void)
 {
-        int address, err;
         struct resource res = { .flags = IORESOURCE_IO };
-
-#ifdef CONFIG_DMI
-        const char *board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
-
-        /* safety check, refuse to load on non Abit motherboards */
-        if (!force && (!board_vendor ||
-                        strcmp(board_vendor, "http://www.abit.com.tw/")))
-                return -ENODEV;
-#endif
-
-        address = abituguru3_detect();
-        if (address < 0)
-                return address;
+        int err;
+
+        /* Attempt DMI detection first */
+        err = abituguru3_dmi_detect();
+        if (err < 0)
+                return err;
+
+        /* Fall back to manual detection if there was no exact
+         * board name match, or force was specified.
+         */
+        if (err > 0) {
+                err = abituguru3_detect();
+                if (err)
+                        return err;
+        }
 
         err = platform_driver_register(&abituguru3_driver);
         if (err)
                 goto exit;
 
-        abituguru3_pdev = platform_device_alloc(ABIT_UGURU3_NAME, address);
+        abituguru3_pdev = platform_device_alloc(ABIT_UGURU3_NAME,
+                                                ABIT_UGURU3_BASE);
         if (!abituguru3_pdev) {
                 printk(KERN_ERR ABIT_UGURU3_NAME
                         ": Device allocation failed\n");
@@ -1166,8 +1221,8 @@ static int __init abituguru3_init(void)
                 goto exit_driver_unregister;
         }
 
-        res.start = address;
-        res.end = address + ABIT_UGURU3_REGION_LENGTH - 1;
+        res.start = ABIT_UGURU3_BASE;
+        res.end = ABIT_UGURU3_BASE + ABIT_UGURU3_REGION_LENGTH - 1;
         res.name = ABIT_UGURU3_NAME;
 
         err = platform_device_add_resources(abituguru3_pdev, &res, 1);
diff --git a/drivers/hwmon/ad7414.c b/drivers/hwmon/ad7414.c
new file mode 100644
index 000000000000..bfda8c80ef24
--- /dev/null
+++ b/drivers/hwmon/ad7414.c
@@ -0,0 +1,268 @@
+/*
+ * An hwmon driver for the Analog Devices AD7414
+ *
+ * Copyright 2006 Stefan Roese <sr at denx.de>, DENX Software Engineering
+ *
+ * Copyright (c) 2008 PIKA Technologies
+ *   Sean MacLennan <smaclennan@pikatech.com>
+ *
+ * Copyright (c) 2008 Spansion Inc.
+ *   Frank Edelhaeuser <frank.edelhaeuser at spansion.com>
+ *   (converted to "new style" I2C driver model, removed checkpatch.pl warnings)
+ *
+ * Based on ad7418.c
+ * Copyright 2006 Tower Technologies, Alessandro Zummo <a.zummo at towertech.it>
+ *
+ * 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.
+ */
+
+#include <linux/module.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>
+
+
+/* AD7414 registers */
+#define AD7414_REG_TEMP         0x00
+#define AD7414_REG_CONF         0x01
+#define AD7414_REG_T_HIGH       0x02
+#define AD7414_REG_T_LOW        0x03
+
+static u8 AD7414_REG_LIMIT[] = { AD7414_REG_T_HIGH, AD7414_REG_T_LOW };
+
+struct ad7414_data {
+        struct device           *hwmon_dev;
+        struct mutex            lock;   /* atomic read data updates */
+        char                    valid;  /* !=0 if following fields are valid */
+        unsigned long           next_update;    /* In jiffies */
+        s16                     temp_input;     /* Register values */
+        s8                      temps[ARRAY_SIZE(AD7414_REG_LIMIT)];
+};
+
+/* REG: (0.25C/bit, two's complement) << 6 */
+static inline int ad7414_temp_from_reg(s16 reg)
+{
+        /* use integer division instead of equivalent right shift to
+         * guarantee arithmetic shift and preserve the sign
+         */
+        return ((int)reg / 64) * 250;
+}
+
+static inline int ad7414_read(struct i2c_client *client, u8 reg)
+{
+        if (reg == AD7414_REG_TEMP) {
+                int value = i2c_smbus_read_word_data(client, reg);
+                return (value < 0) ? value : swab16(value);
+        } else
+                return i2c_smbus_read_byte_data(client, reg);
+}
+
+static inline int ad7414_write(struct i2c_client *client, u8 reg, u8 value)
+{
+        return i2c_smbus_write_byte_data(client, reg, value);
+}
+
+static struct ad7414_data *ad7414_update_device(struct device *dev)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct ad7414_data *data = i2c_get_clientdata(client);
+
+        mutex_lock(&data->lock);
+
+        if (time_after(jiffies, data->next_update) || !data->valid) {
+                int value, i;
+
+                dev_dbg(&client->dev, "starting ad7414 update\n");
+
+                value = ad7414_read(client, AD7414_REG_TEMP);
+                if (value < 0)
+                        dev_dbg(&client->dev, "AD7414_REG_TEMP err %d\n",
+                                value);
+                else
+                        data->temp_input = value;
+
+                for (i = 0; i < ARRAY_SIZE(AD7414_REG_LIMIT); ++i) {
+                        value = ad7414_read(client, AD7414_REG_LIMIT[i]);
+                        if (value < 0)
+                                dev_dbg(&client->dev, "AD7414 reg %d err %d\n",
+                                        AD7414_REG_LIMIT[i], value);
+                        else
+                                data->temps[i] = value;
+                }
+
+                data->next_update = jiffies + HZ + HZ / 2;
+                data->valid = 1;
+        }
+
+        mutex_unlock(&data->lock);
+
+        return data;
+}
+
+static ssize_t show_temp_input(struct device *dev,
+                               struct device_attribute *attr, char *buf)
+{
+        struct ad7414_data *data = ad7414_update_device(dev);
+        return sprintf(buf, "%d\n", ad7414_temp_from_reg(data->temp_input));
+}
+static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp_input, NULL, 0);
+
+static ssize_t show_max_min(struct device *dev, struct device_attribute *attr,
+                          char *buf)
+{
+        int index = to_sensor_dev_attr(attr)->index;
+        struct ad7414_data *data = ad7414_update_device(dev);
+        return sprintf(buf, "%d\n", data->temps[index] * 1000);
+}
+
+static ssize_t set_max_min(struct device *dev,
+                           struct device_attribute *attr,
+                           const char *buf, size_t count)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct ad7414_data *data = i2c_get_clientdata(client);
+        int index = to_sensor_dev_attr(attr)->index;
+        u8 reg = AD7414_REG_LIMIT[index];
+        long temp = simple_strtol(buf, NULL, 10);
+
+        temp = SENSORS_LIMIT(temp, -40000, 85000);
+        temp = (temp + (temp < 0 ? -500 : 500)) / 1000;
+
+        mutex_lock(&data->lock);
+        data->temps[index] = temp;
+        ad7414_write(client, reg, temp);
+        mutex_unlock(&data->lock);
+        return count;
+}
+
+static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO,
+                          show_max_min, set_max_min, 0);
+static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO,
+                          show_max_min, set_max_min, 1);
+
+static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
+                          char *buf)
+{
+        int bitnr = to_sensor_dev_attr(attr)->index;
+        struct ad7414_data *data = ad7414_update_device(dev);
+        int value = (data->temp_input >> bitnr) & 1;
+        return sprintf(buf, "%d\n", value);
+}
+
+static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 3);
+static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 4);
+
+static struct attribute *ad7414_attributes[] = {
+        &sensor_dev_attr_temp1_input.dev_attr.attr,
+        &sensor_dev_attr_temp1_max.dev_attr.attr,
+        &sensor_dev_attr_temp1_min.dev_attr.attr,
+        &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
+        NULL
+};
+
+static const struct attribute_group ad7414_group = {
+        .attrs = ad7414_attributes,
+};
+
+static int ad7414_probe(struct i2c_client *client,
+                        const struct i2c_device_id *dev_id)
+{
+        struct ad7414_data *data;
+        int conf;
+        int err = 0;
+
+        if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA |
+                                     I2C_FUNC_SMBUS_READ_WORD_DATA))
+                goto exit;
+
+        data = kzalloc(sizeof(struct ad7414_data), GFP_KERNEL);
+        if (!data) {
+                err = -ENOMEM;
+                goto exit;
+        }
+
+        i2c_set_clientdata(client, data);
+        mutex_init(&data->lock);
+
+        dev_info(&client->dev, "chip found\n");
+
+        /* Make sure the chip is powered up. */
+        conf = i2c_smbus_read_byte_data(client, AD7414_REG_CONF);
+        if (conf < 0)
+                dev_warn(&client->dev,
+                         "ad7414_probe unable to read config register.\n");
+        else {
+                conf &= ~(1 << 7);
+                i2c_smbus_write_byte_data(client, AD7414_REG_CONF, conf);
+        }
+
+        /* Register sysfs hooks */
+        err = sysfs_create_group(&client->dev.kobj, &ad7414_group);
+        if (err)
+                goto exit_free;
+
+        data->hwmon_dev = hwmon_device_register(&client->dev);
+        if (IS_ERR(data->hwmon_dev)) {
+                err = PTR_ERR(data->hwmon_dev);
+                goto exit_remove;
+        }
+
+        return 0;
+
+exit_remove:
+        sysfs_remove_group(&client->dev.kobj, &ad7414_group);
+exit_free:
+        kfree(data);
+exit:
+        return err;
+}
+
+static int __devexit ad7414_remove(struct i2c_client *client)
+{
+        struct ad7414_data *data = i2c_get_clientdata(client);
+
+        hwmon_device_unregister(data->hwmon_dev);
+        sysfs_remove_group(&client->dev.kobj, &ad7414_group);
+        kfree(data);
+        return 0;
+}
+
+static const struct i2c_device_id ad7414_id[] = {
+        { "ad7414", 0 },
+        {}
+};
+
+static struct i2c_driver ad7414_driver = {
+        .driver = {
+                .name   = "ad7414",
+        },
+        .probe  = ad7414_probe,
+        .remove = __devexit_p(ad7414_remove),
+        .id_table = ad7414_id,
+};
+
+static int __init ad7414_init(void)
+{
+        return i2c_add_driver(&ad7414_driver);
+}
+module_init(ad7414_init);
+
+static void __exit ad7414_exit(void)
+{
+        i2c_del_driver(&ad7414_driver);
+}
+module_exit(ad7414_exit);
+
+MODULE_AUTHOR("Stefan Roese <sr at denx.de>, "
+              "Frank Edelhaeuser <frank.edelhaeuser at spansion.com>");
+
+MODULE_DESCRIPTION("AD7414 driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/hwmon/adcxx.c b/drivers/hwmon/adcxx.c
new file mode 100644
index 000000000000..242294db3db6
--- /dev/null
+++ b/drivers/hwmon/adcxx.c
@@ -0,0 +1,329 @@
+/*
+ * adcxx.c
+ *
+ * The adcxx4s is an AD converter family from National Semiconductor (NS).
+ *
+ * Copyright (c) 2008 Marc Pignat <marc.pignat@hevs.ch>
+ *
+ * The adcxx4s communicates with a host processor via an SPI/Microwire Bus
+ * interface. This driver supports the whole family of devices with name
+ * ADC<bb><c>S<sss>, where
+ * * bb is the resolution in number of bits (8, 10, 12)
+ * * c is the number of channels (1, 2, 4, 8)
+ * * sss is the maximum conversion speed (021 for 200 kSPS, 051 for 500 kSPS
+ *   and 101 for 1 MSPS)
+ *
+ * Complete datasheets are available at National's website here:
+ * http://www.national.com/ds/DC/ADC<bb><c>S<sss>.pdf
+ *
+ * Handling of 8, 10 and 12 bits converters are the same, the
+ * unavailable bits are 0 :)
+ *
+ * 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/init.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/device.h>
+#include <linux/err.h>
+#include <linux/sysfs.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+#include <linux/mutex.h>
+#include <linux/spi/spi.h>
+
+#define DRVNAME         "adcxx"
+
+struct adcxx {
+        struct device *hwmon_dev;
+        struct mutex lock;
+        u32 channels;
+        u32 reference; /* in millivolts */
+};
+
+/* sysfs hook function */
+static ssize_t adcxx_read(struct device *dev,
+                struct device_attribute *devattr, char *buf)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        struct adcxx *adc = dev_get_drvdata(&spi->dev);
+        u8 tx_buf[2] = { attr->index << 3 }; /* other bits are don't care */
+        u8 rx_buf[2];
+        int status;
+        int value;
+
+        if (mutex_lock_interruptible(&adc->lock))
+                return -ERESTARTSYS;
+
+        status = spi_write_then_read(spi, tx_buf, sizeof(tx_buf),
+                                        rx_buf, sizeof(rx_buf));
+        if (status < 0) {
+                dev_warn(dev, "spi_write_then_read failed with status %d\n",
+                                status);
+                goto out;
+        }
+
+        value = (rx_buf[0] << 8) + rx_buf[1];
+        dev_dbg(dev, "raw value = 0x%x\n", value);
+
+        value = value * adc->reference >> 12;
+        status = sprintf(buf, "%d\n", value);
+out:
+        mutex_unlock(&adc->lock);
+        return status;
+}
+
+static ssize_t adcxx_show_min(struct device *dev,
+                struct device_attribute *devattr, char *buf)
+{
+        /* The minimum reference is 0 for this chip family */
+        return sprintf(buf, "0\n");
+}
+
+static ssize_t adcxx_show_max(struct device *dev,
+                struct device_attribute *devattr, char *buf)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        struct adcxx *adc = dev_get_drvdata(&spi->dev);
+        u32 reference;
+
+        if (mutex_lock_interruptible(&adc->lock))
+                return -ERESTARTSYS;
+
+        reference = adc->reference;
+
+        mutex_unlock(&adc->lock);
+
+        return sprintf(buf, "%d\n", reference);
+}
+
+static ssize_t adcxx_set_max(struct device *dev,
+        struct device_attribute *devattr, const char *buf, size_t count)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        struct adcxx *adc = dev_get_drvdata(&spi->dev);
+        unsigned long value;
+
+        if (strict_strtoul(buf, 10, &value))
+                return -EINVAL;
+
+        if (mutex_lock_interruptible(&adc->lock))
+                return -ERESTARTSYS;
+
+        adc->reference = value;
+
+        mutex_unlock(&adc->lock);
+
+        return count;
+}
+
+static ssize_t adcxx_show_name(struct device *dev, struct device_attribute
+                              *devattr, char *buf)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        struct adcxx *adc = dev_get_drvdata(&spi->dev);
+
+        return sprintf(buf, "adcxx%ds\n", adc->channels);
+}
+
+static struct sensor_device_attribute ad_input[] = {
+        SENSOR_ATTR(name, S_IRUGO, adcxx_show_name, NULL, 0),
+        SENSOR_ATTR(in_min, S_IRUGO, adcxx_show_min, NULL, 0),
+        SENSOR_ATTR(in_max, S_IWUSR | S_IRUGO, adcxx_show_max,
+                                        adcxx_set_max, 0),
+        SENSOR_ATTR(in0_input, S_IRUGO, adcxx_read, NULL, 0),
+        SENSOR_ATTR(in1_input, S_IRUGO, adcxx_read, NULL, 1),
+        SENSOR_ATTR(in2_input, S_IRUGO, adcxx_read, NULL, 2),
+        SENSOR_ATTR(in3_input, S_IRUGO, adcxx_read, NULL, 3),
+        SENSOR_ATTR(in4_input, S_IRUGO, adcxx_read, NULL, 4),
+        SENSOR_ATTR(in5_input, S_IRUGO, adcxx_read, NULL, 5),
+        SENSOR_ATTR(in6_input, S_IRUGO, adcxx_read, NULL, 6),
+        SENSOR_ATTR(in7_input, S_IRUGO, adcxx_read, NULL, 7),
+};
+
+/*----------------------------------------------------------------------*/
+
+static int __devinit adcxx_probe(struct spi_device *spi, int channels)
+{
+        struct adcxx *adc;
+        int status;
+        int i;
+
+        adc = kzalloc(sizeof *adc, GFP_KERNEL);
+        if (!adc)
+                return -ENOMEM;
+
+        /* set a default value for the reference */
+        adc->reference = 3300;
+        adc->channels = channels;
+        mutex_init(&adc->lock);
+
+        mutex_lock(&adc->lock);
+
+        dev_set_drvdata(&spi->dev, adc);
+
+        for (i = 0; i < 3 + adc->channels; i++) {
+                status = device_create_file(&spi->dev, &ad_input[i].dev_attr);
+                if (status) {
+                        dev_err(&spi->dev, "device_create_file failed.\n");
+                        goto out_err;
+                }
+        }
+
+        adc->hwmon_dev = hwmon_device_register(&spi->dev);
+        if (IS_ERR(adc->hwmon_dev)) {
+                dev_err(&spi->dev, "hwmon_device_register failed.\n");
+                status = PTR_ERR(adc->hwmon_dev);
+                goto out_err;
+        }
+
+        mutex_unlock(&adc->lock);
+        return 0;
+
+out_err:
+        for (i--; i >= 0; i--)
+                device_remove_file(&spi->dev, &ad_input[i].dev_attr);
+
+        dev_set_drvdata(&spi->dev, NULL);
+        mutex_unlock(&adc->lock);
+        kfree(adc);
+        return status;
+}
+
+static int __devinit adcxx1s_probe(struct spi_device *spi)
+{
+        return adcxx_probe(spi, 1);
+}
+
+static int __devinit adcxx2s_probe(struct spi_device *spi)
+{
+        return adcxx_probe(spi, 2);
+}
+
+static int __devinit adcxx4s_probe(struct spi_device *spi)
+{
+        return adcxx_probe(spi, 4);
+}
+
+static int __devinit adcxx8s_probe(struct spi_device *spi)
+{
+        return adcxx_probe(spi, 8);
+}
+
+static int __devexit adcxx_remove(struct spi_device *spi)
+{
+        struct adcxx *adc = dev_get_drvdata(&spi->dev);
+        int i;
+
+        mutex_lock(&adc->lock);
+        hwmon_device_unregister(adc->hwmon_dev);
+        for (i = 0; i < 3 + adc->channels; i++)
+                device_remove_file(&spi->dev, &ad_input[i].dev_attr);
+
+        dev_set_drvdata(&spi->dev, NULL);
+        mutex_unlock(&adc->lock);
+        kfree(adc);
+
+        return 0;
+}
+
+static struct spi_driver adcxx1s_driver = {
+        .driver = {
+                .name   = "adcxx1s",
+                .owner  = THIS_MODULE,
+        },
+        .probe  = adcxx1s_probe,
+        .remove = __devexit_p(adcxx_remove),
+};
+
+static struct spi_driver adcxx2s_driver = {
+        .driver = {
+                .name   = "adcxx2s",
+                .owner  = THIS_MODULE,
+        },
+        .probe  = adcxx2s_probe,
+        .remove = __devexit_p(adcxx_remove),
+};
+
+static struct spi_driver adcxx4s_driver = {
+        .driver = {
+                .name   = "adcxx4s",
+                .owner  = THIS_MODULE,
+        },
+        .probe  = adcxx4s_probe,
+        .remove = __devexit_p(adcxx_remove),
+};
+
+static struct spi_driver adcxx8s_driver = {
+        .driver = {
+                .name   = "adcxx8s",
+                .owner  = THIS_MODULE,
+        },
+        .probe  = adcxx8s_probe,
+        .remove = __devexit_p(adcxx_remove),
+};
+
+static int __init init_adcxx(void)
+{
+        int status;
+        status = spi_register_driver(&adcxx1s_driver);
+        if (status)
+                goto reg_1_failed;
+
+        status = spi_register_driver(&adcxx2s_driver);
+        if (status)
+                goto reg_2_failed;
+
+        status = spi_register_driver(&adcxx4s_driver);
+        if (status)
+                goto reg_4_failed;
+
+        status = spi_register_driver(&adcxx8s_driver);
+        if (status)
+                goto reg_8_failed;
+
+        return status;
+
+reg_8_failed:
+        spi_unregister_driver(&adcxx4s_driver);
+reg_4_failed:
+        spi_unregister_driver(&adcxx2s_driver);
+reg_2_failed:
+        spi_unregister_driver(&adcxx1s_driver);
+reg_1_failed:
+        return status;
+}
+
+static void __exit exit_adcxx(void)
+{
+        spi_unregister_driver(&adcxx1s_driver);
+        spi_unregister_driver(&adcxx2s_driver);
+        spi_unregister_driver(&adcxx4s_driver);
+        spi_unregister_driver(&adcxx8s_driver);
+}
+
+module_init(init_adcxx);
+module_exit(exit_adcxx);
+
+MODULE_AUTHOR("Marc Pignat");
+MODULE_DESCRIPTION("National Semiconductor adcxx8sxxx Linux driver");
+MODULE_LICENSE("GPL");
+
+MODULE_ALIAS("adcxx1s");
+MODULE_ALIAS("adcxx2s");
+MODULE_ALIAS("adcxx4s");
+MODULE_ALIAS("adcxx8s");
diff --git a/drivers/hwmon/adm1026.c b/drivers/hwmon/adm1026.c
index 7fe2441fc845..ff7de40b6e35 100644
--- a/drivers/hwmon/adm1026.c
+++ b/drivers/hwmon/adm1026.c
@@ -279,7 +279,6 @@ struct adm1026_data {
         u8 fan_min[8];          /* Register value */
         u8 fan_div[8];          /* Decoded value */
         struct pwm_data pwm1;   /* Pwm control values */
-        int vid;                /* Decoded value */
         u8 vrm;                 /* VRM version */
         u8 analog_out;          /* Register value (DAC) */
         long alarms;            /* Register encoding, combined */
@@ -455,7 +454,7 @@ static void adm1026_print_gpio(struct i2c_client *client)
         struct adm1026_data *data = i2c_get_clientdata(client);
         int i;
 
-        dev_dbg(&client->dev, "GPIO config is:");
+        dev_dbg(&client->dev, "GPIO config is:\n");
         for (i = 0;i <= 7;++i) {
                 if (data->config2 & (1 << i)) {
                         dev_dbg(&client->dev, "\t%sGP%s%d\n",
@@ -697,8 +696,6 @@ static struct adm1026_data *adm1026_update_device(struct device *dev)
                 data->last_config = jiffies;
         }; /* last_config */
 
-        dev_dbg(&client->dev, "Setting VID from GPIO11-15.\n");
-        data->vid = (data->gpio >> 11) & 0x1f;
         data->valid = 1;
         mutex_unlock(&data->update_lock);
         return data;
@@ -1215,7 +1212,10 @@ static DEVICE_ATTR(analog_out, S_IRUGO | S_IWUSR, show_analog_out_reg,
 static ssize_t show_vid_reg(struct device *dev, struct device_attribute *attr, char *buf)
 {
         struct adm1026_data *data = adm1026_update_device(dev);
-        return sprintf(buf, "%d\n", vid_from_reg(data->vid & 0x3f, data->vrm));
+        int vid = (data->gpio >> 11) & 0x1f;
+
+        dev_dbg(dev, "Setting VID from GPIO11-15.\n");
+        return sprintf(buf, "%d\n", vid_from_reg(vid, data->vrm));
 }
 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
 
@@ -1681,17 +1681,16 @@ static int adm1026_detect(struct i2c_client *client, int kind,
                         kind = adm1026;
                 } else if (company == ADM1026_COMPANY_ANALOG_DEV
                         && (verstep & 0xf0) == ADM1026_VERSTEP_GENERIC) {
-                        dev_err(&adapter->dev, ": Unrecognized stepping "
+                        dev_err(&adapter->dev, "Unrecognized stepping "
                                 "0x%02x. Defaulting to ADM1026.\n", verstep);
                         kind = adm1026;
                 } else if ((verstep & 0xf0) == ADM1026_VERSTEP_GENERIC) {
-                        dev_err(&adapter->dev, ": Found version/stepping "
+                        dev_err(&adapter->dev, "Found version/stepping "
                                 "0x%02x. Assuming generic ADM1026.\n",
                                 verstep);
                         kind = any_chip;
                 } else {
-                        dev_dbg(&adapter->dev, ": Autodetection "
-                                "failed\n");
+                        dev_dbg(&adapter->dev, "Autodetection failed\n");
                         /* Not an ADM1026 ... */
                         if (kind == 0) { /* User used force=x,y */
                                 dev_err(&adapter->dev, "Generic ADM1026 not "
diff --git a/drivers/hwmon/adm1029.c b/drivers/hwmon/adm1029.c
index ba84ca5923f9..36718150b475 100644
--- a/drivers/hwmon/adm1029.c
+++ b/drivers/hwmon/adm1029.c
@@ -179,7 +179,8 @@ show_fan(struct device *dev, struct device_attribute *devattr, char *buf)
         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
         struct adm1029_data *data = adm1029_update_device(dev);
         u16 val;
-        if (data->fan[attr->index] == 0 || data->fan_div[attr->index] == 0
+        if (data->fan[attr->index] == 0
+            || (data->fan_div[attr->index] & 0xC0) == 0
             || data->fan[attr->index] == 255) {
                 return sprintf(buf, "0\n");
         }
@@ -194,7 +195,7 @@ show_fan_div(struct device *dev, struct device_attribute *devattr, char *buf)
 {
         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
         struct adm1029_data *data = adm1029_update_device(dev);
-        if (data->fan_div[attr->index] == 0)
+        if ((data->fan_div[attr->index] & 0xC0) == 0)
                 return sprintf(buf, "0\n");
         return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[attr->index]));
 }
diff --git a/drivers/hwmon/adt7473.c b/drivers/hwmon/adt7473.c
index ce4a7cb5a116..b9a8ea30c99c 100644
--- a/drivers/hwmon/adt7473.c
+++ b/drivers/hwmon/adt7473.c
@@ -39,32 +39,20 @@ I2C_CLIENT_INSMOD_1(adt7473);
 #define ADT7473_REG_BASE_ADDR                   0x20
 
 #define ADT7473_REG_VOLT_BASE_ADDR              0x21
-#define ADT7473_REG_VOLT_MAX_ADDR               0x22
 #define ADT7473_REG_VOLT_MIN_BASE_ADDR          0x46
-#define ADT7473_REG_VOLT_MIN_MAX_ADDR           0x49
 
 #define ADT7473_REG_TEMP_BASE_ADDR              0x25
-#define ADT7473_REG_TEMP_MAX_ADDR               0x27
 #define ADT7473_REG_TEMP_LIMITS_BASE_ADDR       0x4E
-#define ADT7473_REG_TEMP_LIMITS_MAX_ADDR        0x53
 #define ADT7473_REG_TEMP_TMIN_BASE_ADDR         0x67
-#define ADT7473_REG_TEMP_TMIN_MAX_ADDR          0x69
 #define ADT7473_REG_TEMP_TMAX_BASE_ADDR         0x6A
-#define ADT7473_REG_TEMP_TMAX_MAX_ADDR          0x6C
 
 #define ADT7473_REG_FAN_BASE_ADDR               0x28
-#define ADT7473_REG_FAN_MAX_ADDR                0x2F
 #define ADT7473_REG_FAN_MIN_BASE_ADDR           0x54
-#define ADT7473_REG_FAN_MIN_MAX_ADDR            0x5B
 
 #define ADT7473_REG_PWM_BASE_ADDR               0x30
-#define ADT7473_REG_PWM_MAX_ADDR                0x32
 #define ADT7473_REG_PWM_MIN_BASE_ADDR           0x64
-#define ADT7473_REG_PWM_MIN_MAX_ADDR            0x66
 #define ADT7473_REG_PWM_MAX_BASE_ADDR           0x38
-#define ADT7473_REG_PWM_MAX_MAX_ADDR            0x3A
 #define ADT7473_REG_PWM_BHVR_BASE_ADDR          0x5C
-#define ADT7473_REG_PWM_BHVR_MAX_ADDR           0x5E
 #define         ADT7473_PWM_BHVR_MASK           0xE0
 #define         ADT7473_PWM_BHVR_SHIFT          5
 
@@ -102,7 +90,6 @@ I2C_CLIENT_INSMOD_1(adt7473);
 #define         ADT7473_FAN4_ALARM              0x20
 #define         ADT7473_R1T_SHORT               0x40
 #define         ADT7473_R2T_SHORT               0x80
-#define ADT7473_REG_MAX_ADDR                    0x80
 
 #define ALARM2(x)       ((x) << 8)
 
@@ -332,35 +319,24 @@ out:
 }
 
 /*
- * On this chip, voltages are given as a count of steps between a minimum
- * and maximum voltage, not a direct voltage.
+ * Conversions
  */
-static const int volt_convert_table[][2] = {
-        {2997, 3},
-        {4395, 4},
+
+/* IN are scaled acording to built-in resistors */
+static const int adt7473_scaling[] = {  /* .001 Volts */
+        2250, 3300
 };
+#define SCALE(val, from, to)    (((val) * (to) + ((from) / 2)) / (from))
 
 static int decode_volt(int volt_index, u8 raw)
 {
-        int cmax = volt_convert_table[volt_index][0];
-        int cmin = volt_convert_table[volt_index][1];
-        return ((raw * (cmax - cmin)) / 255) + cmin;
+        return SCALE(raw, 192, adt7473_scaling[volt_index]);
 }
 
 static u8 encode_volt(int volt_index, int cooked)
 {
-        int cmax = volt_convert_table[volt_index][0];
-        int cmin = volt_convert_table[volt_index][1];
-        u8 x;
-
-        if (cooked > cmax)
-                cooked = cmax;
-        else if (cooked < cmin)
-                cooked = cmin;
-
-        x = ((cooked - cmin) * 255) / (cmax - cmin);
-
-        return x;
+        int raw = SCALE(cooked, adt7473_scaling[volt_index], 192);
+        return SENSORS_LIMIT(raw, 0, 255);
 }
 
 static ssize_t show_volt_min(struct device *dev,
@@ -583,10 +559,9 @@ static ssize_t set_max_duty_at_crit(struct device *dev,
         struct i2c_client *client = to_i2c_client(dev);
         struct adt7473_data *data = i2c_get_clientdata(client);
         int temp = simple_strtol(buf, NULL, 10);
-        temp = temp && 0xFF;
 
         mutex_lock(&data->lock);
-        data->max_duty_at_overheat = temp;
+        data->max_duty_at_overheat = !!temp;
         reg = i2c_smbus_read_byte_data(client, ADT7473_REG_CFG4);
         if (temp)
                 reg |= ADT7473_CFG4_MAX_DUTY_AT_OVT;
diff --git a/drivers/hwmon/ams/ams-core.c b/drivers/hwmon/ams/ams-core.c
index fbefa82a015c..6c9ace1b76f6 100644
--- a/drivers/hwmon/ams/ams-core.c
+++ b/drivers/hwmon/ams/ams-core.c
@@ -99,39 +99,31 @@ static struct pmf_irq_client ams_shock_client = {
  */
 static void ams_worker(struct work_struct *work)
 {
-        mutex_lock(&ams_info.lock);
-
-        if (ams_info.has_device) {
-                unsigned long flags;
+        unsigned long flags;
+        u8 irqs_to_clear;
 
-                spin_lock_irqsave(&ams_info.irq_lock, flags);
+        mutex_lock(&ams_info.lock);
 
-                if (ams_info.worker_irqs & AMS_IRQ_FREEFALL) {
-                        if (verbose)
-                                printk(KERN_INFO "ams: freefall detected!\n");
+        spin_lock_irqsave(&ams_info.irq_lock, flags);
+        irqs_to_clear = ams_info.worker_irqs;
 
-                        ams_info.worker_irqs &= ~AMS_IRQ_FREEFALL;
+        if (ams_info.worker_irqs & AMS_IRQ_FREEFALL) {
+                if (verbose)
+                        printk(KERN_INFO "ams: freefall detected!\n");
 
-                        /* we must call this with interrupts enabled */
-                        spin_unlock_irqrestore(&ams_info.irq_lock, flags);
-                        ams_info.clear_irq(AMS_IRQ_FREEFALL);
-                        spin_lock_irqsave(&ams_info.irq_lock, flags);
-                }
+                ams_info.worker_irqs &= ~AMS_IRQ_FREEFALL;
+        }
 
-                if (ams_info.worker_irqs & AMS_IRQ_SHOCK) {
-                        if (verbose)
-                                printk(KERN_INFO "ams: shock detected!\n");
+        if (ams_info.worker_irqs & AMS_IRQ_SHOCK) {
+                if (verbose)
+                        printk(KERN_INFO "ams: shock detected!\n");
 
-                        ams_info.worker_irqs &= ~AMS_IRQ_SHOCK;
+                ams_info.worker_irqs &= ~AMS_IRQ_SHOCK;
+        }
 
-                        /* we must call this with interrupts enabled */
-                        spin_unlock_irqrestore(&ams_info.irq_lock, flags);
-                        ams_info.clear_irq(AMS_IRQ_SHOCK);
-                        spin_lock_irqsave(&ams_info.irq_lock, flags);
-                }
+        spin_unlock_irqrestore(&ams_info.irq_lock, flags);
 
-                spin_unlock_irqrestore(&ams_info.irq_lock, flags);
-        }
+        ams_info.clear_irq(irqs_to_clear);
 
         mutex_unlock(&ams_info.lock);
 }
@@ -223,34 +215,28 @@ int __init ams_init(void)
 
 void ams_exit(void)
 {
-        mutex_lock(&ams_info.lock);
-
-        if (ams_info.has_device) {
-                /* Remove input device */
-                ams_input_exit();
+        /* Remove input device */
+        ams_input_exit();
 
-                /* Shut down implementation */
-                ams_info.exit();
-
-                /* Flush interrupt worker
-                 *
-                 * We do this after ams_info.exit(), because an interrupt might
-                 * have arrived before disabling them.
-                 */
-                flush_scheduled_work();
+        /* Remove attributes */
+        device_remove_file(&ams_info.of_dev->dev, &dev_attr_current);
 
-                /* Remove attributes */
-                device_remove_file(&ams_info.of_dev->dev, &dev_attr_current);
+        /* Shut down implementation */
+        ams_info.exit();
 
-                /* Remove device */
-                of_device_unregister(ams_info.of_dev);
+        /* Flush interrupt worker
+         *
+         * We do this after ams_info.exit(), because an interrupt might
+         * have arrived before disabling them.
+         */
+        flush_scheduled_work();
 
-                /* Remove handler */
-                pmf_unregister_irq_client(&ams_shock_client);
-                pmf_unregister_irq_client(&ams_freefall_client);
-        }
+        /* Remove device */
+        of_device_unregister(ams_info.of_dev);
 
-        mutex_unlock(&ams_info.lock);
+        /* Remove handler */
+        pmf_unregister_irq_client(&ams_shock_client);
+        pmf_unregister_irq_client(&ams_freefall_client);
 }
 
 MODULE_AUTHOR("Stelian Pop, Michael Hanselmann");
diff --git a/drivers/hwmon/ams/ams-i2c.c b/drivers/hwmon/ams/ams-i2c.c
index 957760536a4c..2cbf8a6506c7 100644
--- a/drivers/hwmon/ams/ams-i2c.c
+++ b/drivers/hwmon/ams/ams-i2c.c
@@ -60,26 +60,34 @@ enum ams_i2c_cmd {
         AMS_CMD_START,
 };
 
-static int ams_i2c_attach(struct i2c_adapter *adapter);
-static int ams_i2c_detach(struct i2c_adapter *adapter);
+static int ams_i2c_probe(struct i2c_client *client,
+                         const struct i2c_device_id *id);
+static int ams_i2c_remove(struct i2c_client *client);
+
+static const struct i2c_device_id ams_id[] = {
+        { "ams", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, ams_id);
 
 static struct i2c_driver ams_i2c_driver = {
         .driver = {
                 .name   = "ams",
                 .owner  = THIS_MODULE,
         },
-        .attach_adapter = ams_i2c_attach,
-        .detach_adapter = ams_i2c_detach,
+        .probe          = ams_i2c_probe,
+        .remove         = ams_i2c_remove,
+        .id_table       = ams_id,
 };
 
 static s32 ams_i2c_read(u8 reg)
 {
-        return i2c_smbus_read_byte_data(&ams_info.i2c_client, reg);
+        return i2c_smbus_read_byte_data(ams_info.i2c_client, reg);
 }
 
 static int ams_i2c_write(u8 reg, u8 value)
 {
-        return i2c_smbus_write_byte_data(&ams_info.i2c_client, reg, value);
+        return i2c_smbus_write_byte_data(ams_info.i2c_client, reg, value);
 }
 
 static int ams_i2c_cmd(enum ams_i2c_cmd cmd)
@@ -152,9 +160,9 @@ static void ams_i2c_get_xyz(s8 *x, s8 *y, s8 *z)
         *z = ams_i2c_read(AMS_DATAZ);
 }
 
-static int ams_i2c_attach(struct i2c_adapter *adapter)
+static int ams_i2c_probe(struct i2c_client *client,
+                         const struct i2c_device_id *id)
 {
-        unsigned long bus;
         int vmaj, vmin;
         int result;
 
@@ -162,17 +170,7 @@ static int ams_i2c_attach(struct i2c_adapter *adapter)
         if (unlikely(ams_info.has_device))
                 return -ENODEV;
 
-        if (strncmp(adapter->name, "uni-n", 5))
-                return -ENODEV;
-
-        bus = simple_strtoul(adapter->name + 6, NULL, 10);
-        if (bus != ams_info.i2c_bus)
-                return -ENODEV;
-
-        ams_info.i2c_client.addr = ams_info.i2c_address;
-        ams_info.i2c_client.adapter = adapter;
-        ams_info.i2c_client.driver = &ams_i2c_driver;
-        strcpy(ams_info.i2c_client.name, "Apple Motion Sensor");
+        ams_info.i2c_client = client;
 
         if (ams_i2c_cmd(AMS_CMD_RESET)) {
                 printk(KERN_INFO "ams: Failed to reset the device\n");
@@ -237,7 +235,7 @@ static int ams_i2c_attach(struct i2c_adapter *adapter)
         return 0;
 }
 
-static int ams_i2c_detach(struct i2c_adapter *adapter)
+static int ams_i2c_remove(struct i2c_client *client)
 {
         if (ams_info.has_device) {
                 /* Disable interrupts */
@@ -261,11 +259,7 @@ static void ams_i2c_exit(void)
 
 int __init ams_i2c_init(struct device_node *np)
 {
-        char *tmp_bus;
         int result;
-        const u32 *prop;
-
-        mutex_lock(&ams_info.lock);
 
         /* Set implementation stuff */
         ams_info.of_node = np;
@@ -275,25 +269,7 @@ int __init ams_i2c_init(struct device_node *np)
         ams_info.clear_irq = ams_i2c_clear_irq;
         ams_info.bustype = BUS_I2C;
 
-        /* look for bus either using "reg" or by path */
-        prop = of_get_property(ams_info.of_node, "reg", NULL);
-        if (!prop) {
-                result = -ENODEV;
-
-                goto exit;
-        }
-
-        tmp_bus = strstr(ams_info.of_node->full_name, "/i2c-bus@");
-        if (tmp_bus)
-                ams_info.i2c_bus = *(tmp_bus + 9) - '0';
-        else
-                ams_info.i2c_bus = ((*prop) >> 8) & 0x0f;
-        ams_info.i2c_address = ((*prop) & 0xff) >> 1;
-
         result = i2c_add_driver(&ams_i2c_driver);
 
-exit:
-        mutex_unlock(&ams_info.lock);
-
         return result;
 }
diff --git a/drivers/hwmon/ams/ams-input.c b/drivers/hwmon/ams/ams-input.c
index 7b81e0c2c2d9..8a712392cd38 100644
--- a/drivers/hwmon/ams/ams-input.c
+++ b/drivers/hwmon/ams/ams-input.c
@@ -20,13 +20,15 @@
 #include "ams.h"
 
 static unsigned int joystick;
-module_param(joystick, bool, 0644);
+module_param(joystick, bool, S_IRUGO);
 MODULE_PARM_DESC(joystick, "Enable the input class device on module load");
 
 static unsigned int invert;
-module_param(invert, bool, 0644);
+module_param(invert, bool, S_IWUSR | S_IRUGO);
 MODULE_PARM_DESC(invert, "Invert input data on X and Y axis");
 
+static DEFINE_MUTEX(ams_input_mutex);
+
 static void ams_idev_poll(struct input_polled_dev *dev)
 {
         struct input_dev *idev = dev->input;
@@ -50,13 +52,11 @@ static void ams_idev_poll(struct input_polled_dev *dev)
 }
 
 /* Call with ams_info.lock held! */
-static void ams_input_enable(void)
+static int ams_input_enable(void)
 {
         struct input_dev *input;
         s8 x, y, z;
-
-        if (ams_info.idev)
-                return;
+        int error;
 
         ams_sensors(&x, &y, &z);
         ams_info.xcalib = x;
@@ -65,7 +65,7 @@ static void ams_input_enable(void)
 
         ams_info.idev = input_allocate_polled_device();
         if (!ams_info.idev)
-                return;
+                return -ENOMEM;
 
         ams_info.idev->poll = ams_idev_poll;
         ams_info.idev->poll_interval = 25;
@@ -84,14 +84,18 @@ static void ams_input_enable(void)
         set_bit(EV_KEY, input->evbit);
         set_bit(BTN_TOUCH, input->keybit);
 
-        if (input_register_polled_device(ams_info.idev)) {
+        error = input_register_polled_device(ams_info.idev);
+        if (error) {
                 input_free_polled_device(ams_info.idev);
                 ams_info.idev = NULL;
-                return;
+                return error;
         }
+
+        joystick = 1;
+
+        return 0;
 }
 
-/* Call with ams_info.lock held! */
 static void ams_input_disable(void)
 {
         if (ams_info.idev) {
@@ -99,6 +103,8 @@ static void ams_input_disable(void)
                 input_free_polled_device(ams_info.idev);
                 ams_info.idev = NULL;
         }
+
+        joystick = 0;
 }
 
 static ssize_t ams_input_show_joystick(struct device *dev,
@@ -110,39 +116,42 @@ static ssize_t ams_input_show_joystick(struct device *dev,
 static ssize_t ams_input_store_joystick(struct device *dev,
         struct device_attribute *attr, const char *buf, size_t count)
 {
-        if (sscanf(buf, "%d\n", &joystick) != 1)
+        unsigned long enable;
+        int error = 0;
+
+        if (strict_strtoul(buf, 0, &enable) || enable > 1)
                 return -EINVAL;
 
-        mutex_lock(&ams_info.lock);
+        mutex_lock(&ams_input_mutex);
 
-        if (joystick)
-                ams_input_enable();
-        else
-                ams_input_disable();
+        if (enable != joystick) {
+                if (enable)
+                        error = ams_input_enable();
+                else
+                        ams_input_disable();
+        }
 
-        mutex_unlock(&ams_info.lock);
+        mutex_unlock(&ams_input_mutex);
 
-        return count;
+        return error ? error : count;
 }
 
 static DEVICE_ATTR(joystick, S_IRUGO | S_IWUSR,
         ams_input_show_joystick, ams_input_store_joystick);
 
-/* Call with ams_info.lock held! */
 int ams_input_init(void)
 {
-        int result;
-
-        result = device_create_file(&ams_info.of_dev->dev, &dev_attr_joystick);
-
-        if (!result && joystick)
+        if (joystick)
                 ams_input_enable();
-        return result;
+
+        return device_create_file(&ams_info.of_dev->dev, &dev_attr_joystick);
 }
 
-/* Call with ams_info.lock held! */
 void ams_input_exit(void)
 {
-        ams_input_disable();
         device_remove_file(&ams_info.of_dev->dev, &dev_attr_joystick);
+
+        mutex_lock(&ams_input_mutex);
+        ams_input_disable();
+        mutex_unlock(&ams_input_mutex);
 }
diff --git a/drivers/hwmon/ams/ams-pmu.c b/drivers/hwmon/ams/ams-pmu.c
index 9463e9768f6f..fb18b3d3162b 100644
--- a/drivers/hwmon/ams/ams-pmu.c
+++ b/drivers/hwmon/ams/ams-pmu.c
@@ -149,8 +149,6 @@ int __init ams_pmu_init(struct device_node *np)
         const u32 *prop;
         int result;
 
-        mutex_lock(&ams_info.lock);
-
         /* Set implementation stuff */
         ams_info.of_node = np;
         ams_info.exit = ams_pmu_exit;
@@ -161,10 +159,9 @@ int __init ams_pmu_init(struct device_node *np)
 
         /* Get PMU command, should be 0x4e, but we can never know */
         prop = of_get_property(ams_info.of_node, "reg", NULL);
-        if (!prop) {
-                result = -ENODEV;
-                goto exit;
-        }
+        if (!prop)
+                return -ENODEV;
+
         ams_pmu_cmd = ((*prop) >> 8) & 0xff;
 
         /* Disable interrupts */
@@ -175,7 +172,7 @@ int __init ams_pmu_init(struct device_node *np)
 
         result = ams_sensor_attach();
         if (result < 0)
-                goto exit;
+                return result;
 
         /* Set default values */
         ams_pmu_set_register(AMS_FF_LOW_LIMIT, 0x15);
@@ -198,10 +195,5 @@ int __init ams_pmu_init(struct device_node *np)
 
         printk(KERN_INFO "ams: Found PMU based motion sensor\n");
 
-        result = 0;
-
-exit:
-        mutex_unlock(&ams_info.lock);
-
-        return result;
+        return 0;
 }
diff --git a/drivers/hwmon/ams/ams.h b/drivers/hwmon/ams/ams.h
index a6221e5dd984..5ed387b0bd9a 100644
--- a/drivers/hwmon/ams/ams.h
+++ b/drivers/hwmon/ams/ams.h
@@ -4,7 +4,7 @@
 #include <linux/mutex.h>
 #include <linux/spinlock.h>
 #include <linux/types.h>
-#include <asm/of_device.h>
+#include <linux/of_device.h>
 
 enum ams_irq {
         AMS_IRQ_FREEFALL = 0x01,
@@ -46,9 +46,7 @@ struct ams {
 
 #ifdef CONFIG_SENSORS_AMS_I2C
         /* I2C properties */
-        int i2c_bus;
-        int i2c_address;
-        struct i2c_client i2c_client;
+        struct i2c_client *i2c_client;
 #endif
 
         /* Joystick emulation */
diff --git a/drivers/hwmon/applesmc.c b/drivers/hwmon/applesmc.c
index aacc0c4b809c..bc011da79e14 100644
--- a/drivers/hwmon/applesmc.c
+++ b/drivers/hwmon/applesmc.c
@@ -49,6 +49,9 @@
 
 #define APPLESMC_MAX_DATA_LENGTH 32
 
+#define APPLESMC_MIN_WAIT       0x0040
+#define APPLESMC_MAX_WAIT       0x8000
+
 #define APPLESMC_STATUS_MASK    0x0f
 #define APPLESMC_READ_CMD       0x10
 #define APPLESMC_WRITE_CMD      0x11
@@ -57,8 +60,8 @@
 
 #define KEY_COUNT_KEY           "#KEY" /* r-o ui32 */
 
-#define LIGHT_SENSOR_LEFT_KEY   "ALV0" /* r-o {alv (6 bytes) */
-#define LIGHT_SENSOR_RIGHT_KEY  "ALV1" /* r-o {alv (6 bytes) */
+#define LIGHT_SENSOR_LEFT_KEY   "ALV0" /* r-o {alv (6-10 bytes) */
+#define LIGHT_SENSOR_RIGHT_KEY  "ALV1" /* r-o {alv (6-10 bytes) */
 #define BACKLIGHT_KEY           "LKSB" /* w-o {lkb (2 bytes) */
 
 #define CLAMSHELL_KEY           "MSLD" /* r-o ui8 (unused) */
@@ -98,6 +101,21 @@ static const char* temperature_sensors_sets[][36] = {
           "TH1P", "TH2P", "TH3P", "TMAP", "TMAS", "TMBS", "TM0P", "TM0S",
           "TM1P", "TM1S", "TM2P", "TM2S", "TM3S", "TM8P", "TM8S", "TM9P",
           "TM9S", "TN0H", "TS0C", NULL },
+/* Set 5: iMac */
+        { "TC0D", "TA0P", "TG0P", "TG0D", "TG0H", "TH0P", "Tm0P", "TO0P",
+          "Tp0C", NULL },
+/* Set 6: Macbook3 set */
+        { "TB0T", "TC0D", "TC0P", "TM0P", "TN0P", "TTF0", "TW0P", "Th0H",
+          "Th0S", "Th1H", NULL },
+/* Set 7: Macbook Air */
+        { "TB0T", "TB1S", "TB1T", "TB2S", "TB2T", "TC0D", "TC0P", "TCFP",
+          "TTF0", "TW0P", "Th0H", "Tp0P", "TpFP", "Ts0P", "Ts0S", NULL },
+/* Set 8: Macbook Pro 4,1 (Penryn) */
+        { "TB0T", "TC0D", "TC0P", "TG0D", "TG0H", "TTF0", "TW0P", "Th0H",
+          "Th1H", "Th2H", "Tm0P", "Ts0P", NULL },
+/* Set 9: Macbook Pro 3,1 (Santa Rosa) */
+        { "TALP", "TB0T", "TC0D", "TC0P", "TG0D", "TG0H", "TTF0", "TW0P",
+          "Th0H", "Th1H", "Th2H", "Tm0P", "Ts0P", NULL },
 };
 
 /* List of keys used to read/write fan speeds */
@@ -157,25 +175,25 @@ static unsigned int key_at_index;
 static struct workqueue_struct *applesmc_led_wq;
 
 /*
- * __wait_status - Wait up to 2ms for the status port to get a certain value
+ * __wait_status - Wait up to 32ms for the status port to get a certain value
  * (masked with 0x0f), returning zero if the value is obtained.  Callers must
  * hold applesmc_lock.
  */
 static int __wait_status(u8 val)
 {
-        unsigned int i;
+        int us;
 
         val = val & APPLESMC_STATUS_MASK;
 
-        for (i = 0; i < 200; i++) {
+        for (us = APPLESMC_MIN_WAIT; us < APPLESMC_MAX_WAIT; us <<= 1) {
+                udelay(us);
                 if ((inb(APPLESMC_CMD_PORT) & APPLESMC_STATUS_MASK) == val) {
                         if (debug)
                                 printk(KERN_DEBUG
-                                                "Waited %d us for status %x\n",
-                                                i*10, val);
+                                        "Waited %d us for status %x\n",
+                                        2 * us - APPLESMC_MIN_WAIT, val);
                         return 0;
                 }
-                udelay(10);
         }
 
         printk(KERN_WARNING "applesmc: wait status failed: %x != %x\n",
@@ -185,6 +203,25 @@ static int __wait_status(u8 val)
 }
 
 /*
+ * special treatment of command port - on newer macbooks, it seems necessary
+ * to resend the command byte before polling the status again. Callers must
+ * hold applesmc_lock.
+ */
+static int send_command(u8 cmd)
+{
+        int us;
+        for (us = APPLESMC_MIN_WAIT; us < APPLESMC_MAX_WAIT; us <<= 1) {
+                outb(cmd, APPLESMC_CMD_PORT);
+                udelay(us);
+                if ((inb(APPLESMC_CMD_PORT) & APPLESMC_STATUS_MASK) == 0x0c)
+                        return 0;
+        }
+        printk(KERN_WARNING "applesmc: command failed: %x -> %x\n",
+                cmd, inb(APPLESMC_CMD_PORT));
+        return -EIO;
+}
+
+/*
  * applesmc_read_key - reads len bytes from a given key, and put them in buffer.
  * Returns zero on success or a negative error on failure. Callers must
  * hold applesmc_lock.
@@ -199,8 +236,7 @@ static int applesmc_read_key(const char* key, u8* buffer, u8 len)
                 return -EINVAL;
         }
 
-        outb(APPLESMC_READ_CMD, APPLESMC_CMD_PORT);
-        if (__wait_status(0x0c))
+        if (send_command(APPLESMC_READ_CMD))
                 return -EIO;
 
         for (i = 0; i < 4; i++) {
@@ -243,8 +279,7 @@ static int applesmc_write_key(const char* key, u8* buffer, u8 len)
                 return -EINVAL;
         }
 
-        outb(APPLESMC_WRITE_CMD, APPLESMC_CMD_PORT);
-        if (__wait_status(0x0c))
+        if (send_command(APPLESMC_WRITE_CMD))
                 return -EIO;
 
         for (i = 0; i < 4; i++) {
@@ -278,8 +313,7 @@ static int applesmc_get_key_at_index(int index, char* key)
         readkey[2] = index >> 8;
         readkey[3] = index;
 
-        outb(APPLESMC_GET_KEY_BY_INDEX_CMD, APPLESMC_CMD_PORT);
-        if (__wait_status(0x0c))
+        if (send_command(APPLESMC_GET_KEY_BY_INDEX_CMD))
                 return -EIO;
 
         for (i = 0; i < 4; i++) {
@@ -309,8 +343,7 @@ static int applesmc_get_key_type(char* key, char* type)
 {
         int i;
 
-        outb(APPLESMC_GET_KEY_TYPE_CMD, APPLESMC_CMD_PORT);
-        if (__wait_status(0x0c))
+        if (send_command(APPLESMC_GET_KEY_TYPE_CMD))
                 return -EIO;
 
         for (i = 0; i < 4; i++) {
@@ -319,7 +352,7 @@ static int applesmc_get_key_type(char* key, char* type)
                         return -EIO;
         }
 
-        outb(5, APPLESMC_DATA_PORT);
+        outb(6, APPLESMC_DATA_PORT);
 
         for (i = 0; i < 6; i++) {
                 if (__wait_status(0x05))
@@ -521,17 +554,27 @@ out:
 static ssize_t applesmc_light_show(struct device *dev,
                                 struct device_attribute *attr, char *sysfsbuf)
 {
+        static int data_length;
         int ret;
         u8 left = 0, right = 0;
-        u8 buffer[6];
+        u8 buffer[10], query[6];
 
         mutex_lock(&applesmc_lock);
 
-        ret = applesmc_read_key(LIGHT_SENSOR_LEFT_KEY, buffer, 6);
+        if (!data_length) {
+                ret = applesmc_get_key_type(LIGHT_SENSOR_LEFT_KEY, query);
+                if (ret)
+                        goto out;
+                data_length = clamp_val(query[0], 0, 10);
+                printk(KERN_INFO "applesmc: light sensor data length set to "
+                        "%d\n", data_length);
+        }
+
+        ret = applesmc_read_key(LIGHT_SENSOR_LEFT_KEY, buffer, data_length);
         left = buffer[2];
         if (ret)
                 goto out;
-        ret = applesmc_read_key(LIGHT_SENSOR_RIGHT_KEY, buffer, 6);
+        ret = applesmc_read_key(LIGHT_SENSOR_RIGHT_KEY, buffer, data_length);
         right = buffer[2];
 
 out:
@@ -1223,31 +1266,61 @@ static __initdata struct dmi_match_data applesmc_dmi_data[] = {
         { .accelerometer = 0, .light = 0, .temperature_set = 3 },
 /* MacPro: temperature set 4 */
         { .accelerometer = 0, .light = 0, .temperature_set = 4 },
+/* iMac: temperature set 5 */
+        { .accelerometer = 0, .light = 0, .temperature_set = 5 },
+/* MacBook3: accelerometer and temperature set 6 */
+        { .accelerometer = 1, .light = 0, .temperature_set = 6 },
+/* MacBook Air: accelerometer, backlight and temperature set 7 */
+        { .accelerometer = 1, .light = 1, .temperature_set = 7 },
+/* MacBook Pro 4: accelerometer, backlight and temperature set 8 */
+        { .accelerometer = 1, .light = 1, .temperature_set = 8 },
+/* MacBook Pro 3: accelerometer, backlight and temperature set 9 */
+        { .accelerometer = 1, .light = 1, .temperature_set = 9 },
 };
 
 /* Note that DMI_MATCH(...,"MacBook") will match "MacBookPro1,1".
  * So we need to put "Apple MacBook Pro" before "Apple MacBook". */
 static __initdata struct dmi_system_id applesmc_whitelist[] = {
+        { applesmc_dmi_match, "Apple MacBook Air", {
+          DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
+          DMI_MATCH(DMI_PRODUCT_NAME, "MacBookAir") },
+                &applesmc_dmi_data[7]},
+        { applesmc_dmi_match, "Apple MacBook Pro 4", {
+          DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
+          DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro4") },
+                &applesmc_dmi_data[8]},
+        { applesmc_dmi_match, "Apple MacBook Pro 3", {
+          DMI_MATCH(DMI_BOARD_VENDOR, "Apple"),
+          DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro3") },
+                &applesmc_dmi_data[9]},
         { applesmc_dmi_match, "Apple MacBook Pro", {
           DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
           DMI_MATCH(DMI_PRODUCT_NAME,"MacBookPro") },
-                (void*)&applesmc_dmi_data[0]},
-        { applesmc_dmi_match, "Apple MacBook", {
+                &applesmc_dmi_data[0]},
+        { applesmc_dmi_match, "Apple MacBook (v2)", {
           DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
           DMI_MATCH(DMI_PRODUCT_NAME,"MacBook2") },
-                (void*)&applesmc_dmi_data[1]},
+                &applesmc_dmi_data[1]},
+        { applesmc_dmi_match, "Apple MacBook (v3)", {
+          DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
+          DMI_MATCH(DMI_PRODUCT_NAME,"MacBook3") },
+                &applesmc_dmi_data[6]},
         { applesmc_dmi_match, "Apple MacBook", {
           DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
           DMI_MATCH(DMI_PRODUCT_NAME,"MacBook") },
-                (void*)&applesmc_dmi_data[2]},
+                &applesmc_dmi_data[2]},
         { applesmc_dmi_match, "Apple Macmini", {
           DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
           DMI_MATCH(DMI_PRODUCT_NAME,"Macmini") },
-                (void*)&applesmc_dmi_data[3]},
+                &applesmc_dmi_data[3]},
         { applesmc_dmi_match, "Apple MacPro2", {
           DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
           DMI_MATCH(DMI_PRODUCT_NAME,"MacPro2") },
-                (void*)&applesmc_dmi_data[4]},
+                &applesmc_dmi_data[4]},
+        { applesmc_dmi_match, "Apple iMac", {
+          DMI_MATCH(DMI_BOARD_VENDOR,"Apple"),
+          DMI_MATCH(DMI_PRODUCT_NAME,"iMac") },
+                &applesmc_dmi_data[5]},
         { .ident = NULL }
 };
 
diff --git a/drivers/hwmon/atxp1.c b/drivers/hwmon/atxp1.c
index d191118ba0cb..d6b490d3e36f 100644
--- a/drivers/hwmon/atxp1.c
+++ b/drivers/hwmon/atxp1.c
@@ -31,7 +31,7 @@
 
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("System voltages control via Attansic ATXP1");
-MODULE_VERSION("0.6.2");
+MODULE_VERSION("0.6.3");
 MODULE_AUTHOR("Sebastian Witt <se.witt@gmx.net>");
 
 #define ATXP1_VID       0x00
@@ -289,16 +289,16 @@ static int atxp1_detect(struct i2c_client *new_client, int kind,
         if (!((i2c_smbus_read_byte_data(new_client, 0x3e) == 0) &&
              (i2c_smbus_read_byte_data(new_client, 0x3f) == 0) &&
              (i2c_smbus_read_byte_data(new_client, 0xfe) == 0) &&
-             (i2c_smbus_read_byte_data(new_client, 0xff) == 0) )) {
+             (i2c_smbus_read_byte_data(new_client, 0xff) == 0)))
+                return -ENODEV;
 
-                /* No vendor ID, now checking if registers 0x10,0x11 (non-existent)
-                 * showing the same as register 0x00 */
-                temp = i2c_smbus_read_byte_data(new_client, 0x00);
+        /* No vendor ID, now checking if registers 0x10,0x11 (non-existent)
+         * showing the same as register 0x00 */
+        temp = i2c_smbus_read_byte_data(new_client, 0x00);
 
-                if (!((i2c_smbus_read_byte_data(new_client, 0x10) == temp) &&
-                         (i2c_smbus_read_byte_data(new_client, 0x11) == temp) ))
-                        return -ENODEV;
-        }
+        if (!((i2c_smbus_read_byte_data(new_client, 0x10) == temp) &&
+              (i2c_smbus_read_byte_data(new_client, 0x11) == temp)))
+                return -ENODEV;
 
         /* Get VRM */
         temp = vid_which_vrm();
diff --git a/drivers/hwmon/coretemp.c b/drivers/hwmon/coretemp.c
index 70239acecc8e..93c17223b527 100644
--- a/drivers/hwmon/coretemp.c
+++ b/drivers/hwmon/coretemp.c
@@ -413,10 +413,11 @@ static int __init coretemp_init(void)
         for_each_online_cpu(i) {
                 struct cpuinfo_x86 *c = &cpu_data(i);
 
-                /* check if family 6, models 0xe, 0xf, 0x16, 0x17 */
+                /* check if family 6, models 0xe, 0xf, 0x16, 0x17, 0x1A */
                 if ((c->cpuid_level < 0) || (c->x86 != 0x6) ||
                     !((c->x86_model == 0xe) || (c->x86_model == 0xf) ||
-                        (c->x86_model == 0x16) || (c->x86_model == 0x17))) {
+                        (c->x86_model == 0x16) || (c->x86_model == 0x17) ||
+                        (c->x86_model == 0x1A))) {
 
                         /* supported CPU not found, but report the unknown
                            family 6 CPU */
diff --git a/drivers/hwmon/dme1737.c b/drivers/hwmon/dme1737.c
index 7673f65877e1..27a5d397f9a1 100644
--- a/drivers/hwmon/dme1737.c
+++ b/drivers/hwmon/dme1737.c
@@ -1,11 +1,11 @@
 /*
- * dme1737.c - Driver for the SMSC DME1737, Asus A8000, and SMSC SCH311x
- *             Super-I/O chips integrated hardware monitoring features.
- * Copyright (c) 2007 Juerg Haefliger <juergh@gmail.com>
+ * dme1737.c - Driver for the SMSC DME1737, Asus A8000, SMSC SCH311x and
+ *             SCH5027 Super-I/O chips integrated hardware monitoring features.
+ * Copyright (c) 2007, 2008 Juerg Haefliger <juergh@gmail.com>
  *
  * This driver is an I2C/ISA hybrid, meaning that it uses the I2C bus to access
- * the chip registers if a DME1737 (or A8000) is found and the ISA bus if a
- * SCH311x chip is found. Both types of chips have very similar hardware
+ * the chip registers if a DME1737, A8000, or SCH5027 is found and the ISA bus
+ * if a SCH311x chip is found. Both types of chips have very similar hardware
  * monitoring capabilities but differ in the way they can be accessed.
  *
  * This program is free software; you can redistribute it and/or modify
@@ -48,11 +48,19 @@ static unsigned short force_id;
 module_param(force_id, ushort, 0);
 MODULE_PARM_DESC(force_id, "Override the detected device ID");
 
+static int probe_all_addr;
+module_param(probe_all_addr, bool, 0);
+MODULE_PARM_DESC(probe_all_addr, "Include probing of non-standard LPC "
+                 "addresses");
+
 /* Addresses to scan */
 static const unsigned short normal_i2c[] = {0x2c, 0x2d, 0x2e, I2C_CLIENT_END};
 
 /* Insmod parameters */
-I2C_CLIENT_INSMOD_1(dme1737);
+I2C_CLIENT_INSMOD_2(dme1737, sch5027);
+
+/* ISA chip types */
+enum isa_chips { sch311x = sch5027 + 1 };
 
 /* ---------------------------------------------------------------------
  * Registers
@@ -158,6 +166,7 @@ static const u8 DME1737_BIT_ALARM_FAN[] = {10, 11, 12, 13, 22, 23};
 #define DME1737_VERSTEP         0x88
 #define DME1737_VERSTEP_MASK    0xf8
 #define SCH311X_DEVICE          0x8c
+#define SCH5027_VERSTEP         0x69
 
 /* Length of ISA address segment */
 #define DME1737_EXTENT  2
@@ -166,16 +175,18 @@ static const u8 DME1737_BIT_ALARM_FAN[] = {10, 11, 12, 13, 22, 23};
  * Data structures and manipulation thereof
  * --------------------------------------------------------------------- */
 
-/* For ISA chips, we abuse the i2c_client addr and name fields. We also use
-   the driver field to differentiate between I2C and ISA chips. */
 struct dme1737_data {
-        struct i2c_client client;
+        struct i2c_client *client;      /* for I2C devices only */
         struct device *hwmon_dev;
+        const char *name;
+        unsigned int addr;              /* for ISA devices only */
 
         struct mutex update_lock;
         int valid;                      /* !=0 if following fields are valid */
         unsigned long last_update;      /* in jiffies */
         unsigned long last_vbat;        /* in jiffies */
+        enum chips type;
+        const int *in_nominal;          /* pointer to IN_NOMINAL array */
 
         u8 vid;
         u8 pwm_rr_en;
@@ -210,20 +221,27 @@ struct dme1737_data {
 };
 
 /* Nominal voltage values */
-static const int IN_NOMINAL[] = {5000, 2250, 3300, 5000, 12000, 3300, 3300};
+static const int IN_NOMINAL_DME1737[] = {5000, 2250, 3300, 5000, 12000, 3300,
+                                         3300};
+static const int IN_NOMINAL_SCH311x[] = {2500, 1500, 3300, 5000, 12000, 3300,
+                                         3300};
+static const int IN_NOMINAL_SCH5027[] = {5000, 2250, 3300, 1125, 1125, 3300,
+                                         3300};
+#define IN_NOMINAL(type)        ((type) == sch311x ? IN_NOMINAL_SCH311x : \
+                                 (type) == sch5027 ? IN_NOMINAL_SCH5027 : \
+                                 IN_NOMINAL_DME1737)
 
 /* Voltage input
  * Voltage inputs have 16 bits resolution, limit values have 8 bits
  * resolution. */
-static inline int IN_FROM_REG(int reg, int ix, int res)
+static inline int IN_FROM_REG(int reg, int nominal, int res)
 {
-        return (reg * IN_NOMINAL[ix] + (3 << (res - 3))) / (3 << (res - 2));
+        return (reg * nominal + (3 << (res - 3))) / (3 << (res - 2));
 }
 
-static inline int IN_TO_REG(int val, int ix)
+static inline int IN_TO_REG(int val, int nominal)
 {
-        return SENSORS_LIMIT((val * 192 + IN_NOMINAL[ix] / 2) /
-                             IN_NOMINAL[ix], 0, 255);
+        return SENSORS_LIMIT((val * 192 + nominal / 2) / nominal, 0, 255);
 }
 
 /* Temperature input
@@ -494,11 +512,12 @@ static inline int PWM_OFF_TO_REG(int val, int ix, int reg)
  * before calling dme1737_read or dme1737_write.
  * --------------------------------------------------------------------- */
 
-static u8 dme1737_read(struct i2c_client *client, u8 reg)
+static u8 dme1737_read(const struct dme1737_data *data, u8 reg)
 {
+        struct i2c_client *client = data->client;
         s32 val;
 
-        if (client->driver) { /* I2C device */
+        if (client) { /* I2C device */
                 val = i2c_smbus_read_byte_data(client, reg);
 
                 if (val < 0) {
@@ -507,18 +526,19 @@ static u8 dme1737_read(struct i2c_client *client, u8 reg)
                                  "maintainer.\n", reg);
                 }
         } else { /* ISA device */
-                outb(reg, client->addr);
-                val = inb(client->addr + 1);
+                outb(reg, data->addr);
+                val = inb(data->addr + 1);
         }
 
         return val;
 }
 
-static s32 dme1737_write(struct i2c_client *client, u8 reg, u8 val)
+static s32 dme1737_write(const struct dme1737_data *data, u8 reg, u8 val)
 {
+        struct i2c_client *client = data->client;
         s32 res = 0;
 
-        if (client->driver) { /* I2C device */
+        if (client) { /* I2C device */
                 res = i2c_smbus_write_byte_data(client, reg, val);
 
                 if (res < 0) {
@@ -527,8 +547,8 @@ static s32 dme1737_write(struct i2c_client *client, u8 reg, u8 val)
                                  "maintainer.\n", reg);
                 }
         } else { /* ISA device */
-                outb(reg, client->addr);
-                outb(val, client->addr + 1);
+                outb(reg, data->addr);
+                outb(val, data->addr + 1);
         }
 
         return res;
@@ -537,7 +557,6 @@ static s32 dme1737_write(struct i2c_client *client, u8 reg, u8 val)
 static struct dme1737_data *dme1737_update_device(struct device *dev)
 {
         struct dme1737_data *data = dev_get_drvdata(dev);
-        struct i2c_client *client = &data->client;
         int ix;
         u8 lsb[5];
 
@@ -545,25 +564,28 @@ static struct dme1737_data *dme1737_update_device(struct device *dev)
 
         /* Enable a Vbat monitoring cycle every 10 mins */
         if (time_after(jiffies, data->last_vbat + 600 * HZ) || !data->valid) {
-                dme1737_write(client, DME1737_REG_CONFIG, dme1737_read(client,
+                dme1737_write(data, DME1737_REG_CONFIG, dme1737_read(data,
                                                 DME1737_REG_CONFIG) | 0x10);
                 data->last_vbat = jiffies;
         }
 
         /* Sample register contents every 1 sec */
         if (time_after(jiffies, data->last_update + HZ) || !data->valid) {
-                data->vid = dme1737_read(client, DME1737_REG_VID) & 0x3f;
+                if (data->type != sch5027) {
+                        data->vid = dme1737_read(data, DME1737_REG_VID) &
+                                0x3f;
+                }
 
                 /* In (voltage) registers */
                 for (ix = 0; ix < ARRAY_SIZE(data->in); ix++) {
                         /* Voltage inputs are stored as 16 bit values even
                          * though they have only 12 bits resolution. This is
                          * to make it consistent with the temp inputs. */
-                        data->in[ix] = dme1737_read(client,
+                        data->in[ix] = dme1737_read(data,
                                         DME1737_REG_IN(ix)) << 8;
-                        data->in_min[ix] = dme1737_read(client,
+                        data->in_min[ix] = dme1737_read(data,
                                         DME1737_REG_IN_MIN(ix));
-                        data->in_max[ix] = dme1737_read(client,
+                        data->in_max[ix] = dme1737_read(data,
                                         DME1737_REG_IN_MAX(ix));
                 }
 
@@ -574,14 +596,16 @@ static struct dme1737_data *dme1737_update_device(struct device *dev)
                          * to take advantage of implicit conversions between
                          * register values (2's complement) and temp values
                          * (signed decimal). */
-                        data->temp[ix] = dme1737_read(client,
+                        data->temp[ix] = dme1737_read(data,
                                         DME1737_REG_TEMP(ix)) << 8;
-                        data->temp_min[ix] = dme1737_read(client,
+                        data->temp_min[ix] = dme1737_read(data,
                                         DME1737_REG_TEMP_MIN(ix));
-                        data->temp_max[ix] = dme1737_read(client,
+                        data->temp_max[ix] = dme1737_read(data,
                                         DME1737_REG_TEMP_MAX(ix));
-                        data->temp_offset[ix] = dme1737_read(client,
-                                        DME1737_REG_TEMP_OFFSET(ix));
+                        if (data->type != sch5027) {
+                                data->temp_offset[ix] = dme1737_read(data,
+                                                DME1737_REG_TEMP_OFFSET(ix));
+                        }
                 }
 
                 /* In and temp LSB registers
@@ -589,7 +613,7 @@ static struct dme1737_data *dme1737_update_device(struct device *dev)
                  * which the registers are read (MSB first, then LSB) is
                  * important! */
                 for (ix = 0; ix < ARRAY_SIZE(lsb); ix++) {
-                        lsb[ix] = dme1737_read(client,
+                        lsb[ix] = dme1737_read(data,
                                         DME1737_REG_IN_TEMP_LSB(ix));
                 }
                 for (ix = 0; ix < ARRAY_SIZE(data->in); ix++) {
@@ -608,19 +632,19 @@ static struct dme1737_data *dme1737_update_device(struct device *dev)
                         if (!(data->has_fan & (1 << ix))) {
                                 continue;
                         }
-                        data->fan[ix] = dme1737_read(client,
+                        data->fan[ix] = dme1737_read(data,
                                         DME1737_REG_FAN(ix));
-                        data->fan[ix] |= dme1737_read(client,
+                        data->fan[ix] |= dme1737_read(data,
                                         DME1737_REG_FAN(ix) + 1) << 8;
-                        data->fan_min[ix] = dme1737_read(client,
+                        data->fan_min[ix] = dme1737_read(data,
                                         DME1737_REG_FAN_MIN(ix));
-                        data->fan_min[ix] |= dme1737_read(client,
+                        data->fan_min[ix] |= dme1737_read(data,
                                         DME1737_REG_FAN_MIN(ix) + 1) << 8;
-                        data->fan_opt[ix] = dme1737_read(client,
+                        data->fan_opt[ix] = dme1737_read(data,
                                         DME1737_REG_FAN_OPT(ix));
                         /* fan_max exists only for fan[5-6] */
                         if (ix > 3) {
-                                data->fan_max[ix - 4] = dme1737_read(client,
+                                data->fan_max[ix - 4] = dme1737_read(data,
                                         DME1737_REG_FAN_MAX(ix));
                         }
                 }
@@ -632,61 +656,63 @@ static struct dme1737_data *dme1737_update_device(struct device *dev)
                         if (!(data->has_pwm & (1 << ix))) {
                                 continue;
                         }
-                        data->pwm[ix] = dme1737_read(client,
+                        data->pwm[ix] = dme1737_read(data,
                                         DME1737_REG_PWM(ix));
-                        data->pwm_freq[ix] = dme1737_read(client,
+                        data->pwm_freq[ix] = dme1737_read(data,
                                         DME1737_REG_PWM_FREQ(ix));
                         /* pwm_config and pwm_min exist only for pwm[1-3] */
                         if (ix < 3) {
-                                data->pwm_config[ix] = dme1737_read(client,
+                                data->pwm_config[ix] = dme1737_read(data,
                                                 DME1737_REG_PWM_CONFIG(ix));
-                                data->pwm_min[ix] = dme1737_read(client,
+                                data->pwm_min[ix] = dme1737_read(data,
                                                 DME1737_REG_PWM_MIN(ix));
                         }
                 }
                 for (ix = 0; ix < ARRAY_SIZE(data->pwm_rr); ix++) {
-                        data->pwm_rr[ix] = dme1737_read(client,
+                        data->pwm_rr[ix] = dme1737_read(data,
                                                 DME1737_REG_PWM_RR(ix));
                 }
 
                 /* Thermal zone registers */
                 for (ix = 0; ix < ARRAY_SIZE(data->zone_low); ix++) {
-                        data->zone_low[ix] = dme1737_read(client,
+                        data->zone_low[ix] = dme1737_read(data,
                                         DME1737_REG_ZONE_LOW(ix));
-                        data->zone_abs[ix] = dme1737_read(client,
+                        data->zone_abs[ix] = dme1737_read(data,
                                         DME1737_REG_ZONE_ABS(ix));
                 }
-                for (ix = 0; ix < ARRAY_SIZE(data->zone_hyst); ix++) {
-                        data->zone_hyst[ix] = dme1737_read(client,
+                if (data->type != sch5027) {
+                        for (ix = 0; ix < ARRAY_SIZE(data->zone_hyst); ix++) {
+                                data->zone_hyst[ix] = dme1737_read(data,
                                                 DME1737_REG_ZONE_HYST(ix));
+                        }
                 }
 
                 /* Alarm registers */
-                data->alarms = dme1737_read(client,
+                data->alarms = dme1737_read(data,
                                                 DME1737_REG_ALARM1);
                 /* Bit 7 tells us if the other alarm registers are non-zero and
                  * therefore also need to be read */
                 if (data->alarms & 0x80) {
-                        data->alarms |= dme1737_read(client,
+                        data->alarms |= dme1737_read(data,
                                                 DME1737_REG_ALARM2) << 8;
-                        data->alarms |= dme1737_read(client,
+                        data->alarms |= dme1737_read(data,
                                                 DME1737_REG_ALARM3) << 16;
                 }
 
                 /* The ISA chips require explicit clearing of alarm bits.
                  * Don't worry, an alarm will come back if the condition
                  * that causes it still exists */
-                if (!client->driver) {
+                if (!data->client) {
                         if (data->alarms & 0xff0000) {
-                                dme1737_write(client, DME1737_REG_ALARM3,
+                                dme1737_write(data, DME1737_REG_ALARM3,
                                               0xff);
                         }
                         if (data->alarms & 0xff00) {
-                                dme1737_write(client, DME1737_REG_ALARM2,
+                                dme1737_write(data, DME1737_REG_ALARM2,
                                               0xff);
                         }
                         if (data->alarms & 0xff) {
-                                dme1737_write(client, DME1737_REG_ALARM1,
+                                dme1737_write(data, DME1737_REG_ALARM1,
                                               0xff);
                         }
                 }
@@ -722,13 +748,13 @@ static ssize_t show_in(struct device *dev, struct device_attribute *attr,
 
         switch (fn) {
         case SYS_IN_INPUT:
-                res = IN_FROM_REG(data->in[ix], ix, 16);
+                res = IN_FROM_REG(data->in[ix], data->in_nominal[ix], 16);
                 break;
         case SYS_IN_MIN:
-                res = IN_FROM_REG(data->in_min[ix], ix, 8);
+                res = IN_FROM_REG(data->in_min[ix], data->in_nominal[ix], 8);
                 break;
         case SYS_IN_MAX:
-                res = IN_FROM_REG(data->in_max[ix], ix, 8);
+                res = IN_FROM_REG(data->in_max[ix], data->in_nominal[ix], 8);
                 break;
         case SYS_IN_ALARM:
                 res = (data->alarms >> DME1737_BIT_ALARM_IN[ix]) & 0x01;
@@ -745,7 +771,6 @@ static ssize_t set_in(struct device *dev, struct device_attribute *attr,
                       const char *buf, size_t count)
 {
         struct dme1737_data *data = dev_get_drvdata(dev);
-        struct i2c_client *client = &data->client;
         struct sensor_device_attribute_2
                 *sensor_attr_2 = to_sensor_dev_attr_2(attr);
         int ix = sensor_attr_2->index;
@@ -755,13 +780,13 @@ static ssize_t set_in(struct device *dev, struct device_attribute *attr,
         mutex_lock(&data->update_lock);
         switch (fn) {
         case SYS_IN_MIN:
-                data->in_min[ix] = IN_TO_REG(val, ix);
-                dme1737_write(client, DME1737_REG_IN_MIN(ix),
+                data->in_min[ix] = IN_TO_REG(val, data->in_nominal[ix]);
+                dme1737_write(data, DME1737_REG_IN_MIN(ix),
                               data->in_min[ix]);
                 break;
         case SYS_IN_MAX:
-                data->in_max[ix] = IN_TO_REG(val, ix);
-                dme1737_write(client, DME1737_REG_IN_MAX(ix),
+                data->in_max[ix] = IN_TO_REG(val, data->in_nominal[ix]);
+                dme1737_write(data, DME1737_REG_IN_MAX(ix),
                               data->in_max[ix]);
                 break;
         default:
@@ -825,7 +850,6 @@ static ssize_t set_temp(struct device *dev, struct device_attribute *attr,
                         const char *buf, size_t count)
 {
         struct dme1737_data *data = dev_get_drvdata(dev);
-        struct i2c_client *client = &data->client;
         struct sensor_device_attribute_2
                 *sensor_attr_2 = to_sensor_dev_attr_2(attr);
         int ix = sensor_attr_2->index;
@@ -836,17 +860,17 @@ static ssize_t set_temp(struct device *dev, struct device_attribute *attr,
         switch (fn) {
         case SYS_TEMP_MIN:
                 data->temp_min[ix] = TEMP_TO_REG(val);
-                dme1737_write(client, DME1737_REG_TEMP_MIN(ix),
+                dme1737_write(data, DME1737_REG_TEMP_MIN(ix),
                               data->temp_min[ix]);
                 break;
         case SYS_TEMP_MAX:
                 data->temp_max[ix] = TEMP_TO_REG(val);
-                dme1737_write(client, DME1737_REG_TEMP_MAX(ix),
+                dme1737_write(data, DME1737_REG_TEMP_MAX(ix),
                               data->temp_max[ix]);
                 break;
         case SYS_TEMP_OFFSET:
                 data->temp_offset[ix] = TEMP_TO_REG(val);
-                dme1737_write(client, DME1737_REG_TEMP_OFFSET(ix),
+                dme1737_write(data, DME1737_REG_TEMP_OFFSET(ix),
                               data->temp_offset[ix]);
                 break;
         default:
@@ -914,7 +938,6 @@ static ssize_t set_zone(struct device *dev, struct device_attribute *attr,
                         const char *buf, size_t count)
 {
         struct dme1737_data *data = dev_get_drvdata(dev);
-        struct i2c_client *client = &data->client;
         struct sensor_device_attribute_2
                 *sensor_attr_2 = to_sensor_dev_attr_2(attr);
         int ix = sensor_attr_2->index;
@@ -925,37 +948,37 @@ static ssize_t set_zone(struct device *dev, struct device_attribute *attr,
         switch (fn) {
         case SYS_ZONE_AUTO_POINT1_TEMP_HYST:
                 /* Refresh the cache */
-                data->zone_low[ix] = dme1737_read(client,
+                data->zone_low[ix] = dme1737_read(data,
                                                   DME1737_REG_ZONE_LOW(ix));
                 /* Modify the temp hyst value */
                 data->zone_hyst[ix == 2] = TEMP_HYST_TO_REG(
                                         TEMP_FROM_REG(data->zone_low[ix], 8) -
-                                        val, ix, dme1737_read(client,
+                                        val, ix, dme1737_read(data,
                                         DME1737_REG_ZONE_HYST(ix == 2)));
-                dme1737_write(client, DME1737_REG_ZONE_HYST(ix == 2),
+                dme1737_write(data, DME1737_REG_ZONE_HYST(ix == 2),
                               data->zone_hyst[ix == 2]);
                 break;
         case SYS_ZONE_AUTO_POINT1_TEMP:
                 data->zone_low[ix] = TEMP_TO_REG(val);
-                dme1737_write(client, DME1737_REG_ZONE_LOW(ix),
+                dme1737_write(data, DME1737_REG_ZONE_LOW(ix),
                               data->zone_low[ix]);
                 break;
         case SYS_ZONE_AUTO_POINT2_TEMP:
                 /* Refresh the cache */
-                data->zone_low[ix] = dme1737_read(client,
+                data->zone_low[ix] = dme1737_read(data,
                                                   DME1737_REG_ZONE_LOW(ix));
                 /* Modify the temp range value (which is stored in the upper
                  * nibble of the pwm_freq register) */
                 data->pwm_freq[ix] = TEMP_RANGE_TO_REG(val -
                                         TEMP_FROM_REG(data->zone_low[ix], 8),
-                                        dme1737_read(client,
+                                        dme1737_read(data,
                                         DME1737_REG_PWM_FREQ(ix)));
-                dme1737_write(client, DME1737_REG_PWM_FREQ(ix),
+                dme1737_write(data, DME1737_REG_PWM_FREQ(ix),
                               data->pwm_freq[ix]);
                 break;
         case SYS_ZONE_AUTO_POINT3_TEMP:
                 data->zone_abs[ix] = TEMP_TO_REG(val);
-                dme1737_write(client, DME1737_REG_ZONE_ABS(ix),
+                dme1737_write(data, DME1737_REG_ZONE_ABS(ix),
                               data->zone_abs[ix]);
                 break;
         default:
@@ -1021,7 +1044,6 @@ static ssize_t set_fan(struct device *dev, struct device_attribute *attr,
                        const char *buf, size_t count)
 {
         struct dme1737_data *data = dev_get_drvdata(dev);
-        struct i2c_client *client = &data->client;
         struct sensor_device_attribute_2
                 *sensor_attr_2 = to_sensor_dev_attr_2(attr);
         int ix = sensor_attr_2->index;
@@ -1035,21 +1057,21 @@ static ssize_t set_fan(struct device *dev, struct device_attribute *attr,
                         data->fan_min[ix] = FAN_TO_REG(val, 0);
                 } else {
                         /* Refresh the cache */
-                        data->fan_opt[ix] = dme1737_read(client,
+                        data->fan_opt[ix] = dme1737_read(data,
                                                 DME1737_REG_FAN_OPT(ix));
                         /* Modify the fan min value */
                         data->fan_min[ix] = FAN_TO_REG(val,
                                         FAN_TPC_FROM_REG(data->fan_opt[ix]));
                 }
-                dme1737_write(client, DME1737_REG_FAN_MIN(ix),
+                dme1737_write(data, DME1737_REG_FAN_MIN(ix),
                               data->fan_min[ix] & 0xff);
-                dme1737_write(client, DME1737_REG_FAN_MIN(ix) + 1,
+                dme1737_write(data, DME1737_REG_FAN_MIN(ix) + 1,
                               data->fan_min[ix] >> 8);
                 break;
         case SYS_FAN_MAX:
                 /* Only valid for fan[5-6] */
                 data->fan_max[ix - 4] = FAN_MAX_TO_REG(val);
-                dme1737_write(client, DME1737_REG_FAN_MAX(ix),
+                dme1737_write(data, DME1737_REG_FAN_MAX(ix),
                               data->fan_max[ix - 4]);
                 break;
         case SYS_FAN_TYPE:
@@ -1061,9 +1083,9 @@ static ssize_t set_fan(struct device *dev, struct device_attribute *attr,
                                  val);
                         goto exit;
                 }
-                data->fan_opt[ix] = FAN_TYPE_TO_REG(val, dme1737_read(client,
+                data->fan_opt[ix] = FAN_TYPE_TO_REG(val, dme1737_read(data,
                                         DME1737_REG_FAN_OPT(ix)));
-                dme1737_write(client, DME1737_REG_FAN_OPT(ix),
+                dme1737_write(data, DME1737_REG_FAN_OPT(ix),
                               data->fan_opt[ix]);
                 break;
         default:
@@ -1153,14 +1175,13 @@ static ssize_t show_pwm(struct device *dev, struct device_attribute *attr,
         return sprintf(buf, "%d\n", res);
 }
 
-static struct attribute *dme1737_attr_pwm[];
+static struct attribute *dme1737_pwm_chmod_attr[];
 static void dme1737_chmod_file(struct device*, struct attribute*, mode_t);
 
 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
                        const char *buf, size_t count)
 {
         struct dme1737_data *data = dev_get_drvdata(dev);
-        struct i2c_client *client = &data->client;
         struct sensor_device_attribute_2
                 *sensor_attr_2 = to_sensor_dev_attr_2(attr);
         int ix = sensor_attr_2->index;
@@ -1171,12 +1192,12 @@ static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
         switch (fn) {
         case SYS_PWM:
                 data->pwm[ix] = SENSORS_LIMIT(val, 0, 255);
-                dme1737_write(client, DME1737_REG_PWM(ix), data->pwm[ix]);
+                dme1737_write(data, DME1737_REG_PWM(ix), data->pwm[ix]);
                 break;
         case SYS_PWM_FREQ:
-                data->pwm_freq[ix] = PWM_FREQ_TO_REG(val, dme1737_read(client,
+                data->pwm_freq[ix] = PWM_FREQ_TO_REG(val, dme1737_read(data,
                                                 DME1737_REG_PWM_FREQ(ix)));
-                dme1737_write(client, DME1737_REG_PWM_FREQ(ix),
+                dme1737_write(data, DME1737_REG_PWM_FREQ(ix),
                               data->pwm_freq[ix]);
                 break;
         case SYS_PWM_ENABLE:
@@ -1189,7 +1210,7 @@ static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
                         goto exit;
                 }
                 /* Refresh the cache */
-                data->pwm_config[ix] = dme1737_read(client,
+                data->pwm_config[ix] = dme1737_read(data,
                                                 DME1737_REG_PWM_CONFIG(ix));
                 if (val == PWM_EN_FROM_REG(data->pwm_config[ix])) {
                         /* Bail out if no change */
@@ -1201,14 +1222,14 @@ static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
                         data->pwm_acz[ix] = PWM_ACZ_FROM_REG(
                                                         data->pwm_config[ix]);
                         /* Save the current ramp rate state and disable it */
-                        data->pwm_rr[ix > 0] = dme1737_read(client,
+                        data->pwm_rr[ix > 0] = dme1737_read(data,
                                                 DME1737_REG_PWM_RR(ix > 0));
                         data->pwm_rr_en &= ~(1 << ix);
                         if (PWM_RR_EN_FROM_REG(data->pwm_rr[ix > 0], ix)) {
                                 data->pwm_rr_en |= (1 << ix);
                                 data->pwm_rr[ix > 0] = PWM_RR_EN_TO_REG(0, ix,
                                                         data->pwm_rr[ix > 0]);
-                                dme1737_write(client,
+                                dme1737_write(data,
                                               DME1737_REG_PWM_RR(ix > 0),
                                               data->pwm_rr[ix > 0]);
                         }
@@ -1217,41 +1238,41 @@ static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
                 switch (val) {
                 case 0:
                         /* Change permissions of pwm[ix] to read-only */
-                        dme1737_chmod_file(dev, dme1737_attr_pwm[ix],
+                        dme1737_chmod_file(dev, dme1737_pwm_chmod_attr[ix],
                                            S_IRUGO);
                         /* Turn fan fully on */
                         data->pwm_config[ix] = PWM_EN_TO_REG(0,
                                                         data->pwm_config[ix]);
-                        dme1737_write(client, DME1737_REG_PWM_CONFIG(ix),
+                        dme1737_write(data, DME1737_REG_PWM_CONFIG(ix),
                                       data->pwm_config[ix]);
                         break;
                 case 1:
                         /* Turn on manual mode */
                         data->pwm_config[ix] = PWM_EN_TO_REG(1,
                                                         data->pwm_config[ix]);
-                        dme1737_write(client, DME1737_REG_PWM_CONFIG(ix),
+                        dme1737_write(data, DME1737_REG_PWM_CONFIG(ix),
                                       data->pwm_config[ix]);
                         /* Change permissions of pwm[ix] to read-writeable */
-                        dme1737_chmod_file(dev, dme1737_attr_pwm[ix],
+                        dme1737_chmod_file(dev, dme1737_pwm_chmod_attr[ix],
                                            S_IRUGO | S_IWUSR);
                         break;
                 case 2:
                         /* Change permissions of pwm[ix] to read-only */
-                        dme1737_chmod_file(dev, dme1737_attr_pwm[ix],
+                        dme1737_chmod_file(dev, dme1737_pwm_chmod_attr[ix],
                                            S_IRUGO);
                         /* Turn on auto mode using the saved zone channel
                          * assignment */
                         data->pwm_config[ix] = PWM_ACZ_TO_REG(
                                                         data->pwm_acz[ix],
                                                         data->pwm_config[ix]);
-                        dme1737_write(client, DME1737_REG_PWM_CONFIG(ix),
+                        dme1737_write(data, DME1737_REG_PWM_CONFIG(ix),
                                       data->pwm_config[ix]);
                         /* Enable PWM ramp rate if previously enabled */
                         if (data->pwm_rr_en & (1 << ix)) {
                                 data->pwm_rr[ix > 0] = PWM_RR_EN_TO_REG(1, ix,
-                                                dme1737_read(client,
+                                                dme1737_read(data,
                                                 DME1737_REG_PWM_RR(ix > 0)));
-                                dme1737_write(client,
+                                dme1737_write(data,
                                               DME1737_REG_PWM_RR(ix > 0),
                                               data->pwm_rr[ix > 0]);
                         }
@@ -1261,9 +1282,9 @@ static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
         case SYS_PWM_RAMP_RATE:
                 /* Only valid for pwm[1-3] */
                 /* Refresh the cache */
-                data->pwm_config[ix] = dme1737_read(client,
+                data->pwm_config[ix] = dme1737_read(data,
                                                 DME1737_REG_PWM_CONFIG(ix));
-                data->pwm_rr[ix > 0] = dme1737_read(client,
+                data->pwm_rr[ix > 0] = dme1737_read(data,
                                                 DME1737_REG_PWM_RR(ix > 0));
                 /* Set the ramp rate value */
                 if (val > 0) {
@@ -1276,7 +1297,7 @@ static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
                         data->pwm_rr[ix > 0] = PWM_RR_EN_TO_REG(val > 0, ix,
                                                         data->pwm_rr[ix > 0]);
                 }
-                dme1737_write(client, DME1737_REG_PWM_RR(ix > 0),
+                dme1737_write(data, DME1737_REG_PWM_RR(ix > 0),
                               data->pwm_rr[ix > 0]);
                 break;
         case SYS_PWM_AUTO_CHANNELS_ZONE:
@@ -1290,14 +1311,14 @@ static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
                         goto exit;
                 }
                 /* Refresh the cache */
-                data->pwm_config[ix] = dme1737_read(client,
+                data->pwm_config[ix] = dme1737_read(data,
                                                 DME1737_REG_PWM_CONFIG(ix));
                 if (PWM_EN_FROM_REG(data->pwm_config[ix]) == 2) {
                         /* PWM is already in auto mode so update the temp
                          * channel assignment */
                         data->pwm_config[ix] = PWM_ACZ_TO_REG(val,
                                                 data->pwm_config[ix]);
-                        dme1737_write(client, DME1737_REG_PWM_CONFIG(ix),
+                        dme1737_write(data, DME1737_REG_PWM_CONFIG(ix),
                                       data->pwm_config[ix]);
                 } else {
                         /* PWM is not in auto mode so we save the temp
@@ -1308,7 +1329,7 @@ static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
         case SYS_PWM_AUTO_PWM_MIN:
                 /* Only valid for pwm[1-3] */
                 /* Refresh the cache */
-                data->pwm_min[ix] = dme1737_read(client,
+                data->pwm_min[ix] = dme1737_read(data,
                                                 DME1737_REG_PWM_MIN(ix));
                 /* There are only 2 values supported for the auto_pwm_min
                  * value: 0 or auto_point1_pwm. So if the temperature drops
@@ -1316,20 +1337,20 @@ static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
                  * off or runs at auto_point1_pwm duty-cycle. */
                 if (val > ((data->pwm_min[ix] + 1) / 2)) {
                         data->pwm_rr[0] = PWM_OFF_TO_REG(1, ix,
-                                                dme1737_read(client,
+                                                dme1737_read(data,
                                                 DME1737_REG_PWM_RR(0)));
                 } else {
                         data->pwm_rr[0] = PWM_OFF_TO_REG(0, ix,
-                                                dme1737_read(client,
+                                                dme1737_read(data,
                                                 DME1737_REG_PWM_RR(0)));
                 }
-                dme1737_write(client, DME1737_REG_PWM_RR(0),
+                dme1737_write(data, DME1737_REG_PWM_RR(0),
                               data->pwm_rr[0]);
                 break;
         case SYS_PWM_AUTO_POINT1_PWM:
                 /* Only valid for pwm[1-3] */
                 data->pwm_min[ix] = SENSORS_LIMIT(val, 0, 255);
-                dme1737_write(client, DME1737_REG_PWM_MIN(ix),
+                dme1737_write(data, DME1737_REG_PWM_MIN(ix),
                               data->pwm_min[ix]);
                 break;
         default:
@@ -1377,7 +1398,7 @@ static ssize_t show_name(struct device *dev, struct device_attribute *attr,
 {
         struct dme1737_data *data = dev_get_drvdata(dev);
 
-        return sprintf(buf, "%s\n", data->client.name);
+        return sprintf(buf, "%s\n", data->name);
 }
 
 /* ---------------------------------------------------------------------
@@ -1501,9 +1522,9 @@ SENSOR_DEVICE_ATTR_PWM_1TO3(3);
 /* PWMs 5-6 */
 
 #define SENSOR_DEVICE_ATTR_PWM_5TO6(ix) \
-static SENSOR_DEVICE_ATTR_2(pwm##ix, S_IRUGO | S_IWUSR, \
+static SENSOR_DEVICE_ATTR_2(pwm##ix, S_IRUGO, \
         show_pwm, set_pwm, SYS_PWM, ix-1); \
-static SENSOR_DEVICE_ATTR_2(pwm##ix##_freq, S_IRUGO | S_IWUSR, \
+static SENSOR_DEVICE_ATTR_2(pwm##ix##_freq, S_IRUGO, \
         show_pwm, set_pwm, SYS_PWM_FREQ, ix-1); \
 static SENSOR_DEVICE_ATTR_2(pwm##ix##_enable, S_IRUGO, \
         show_pwm, NULL, SYS_PWM_ENABLE, ix-1)
@@ -1517,225 +1538,286 @@ static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm, set_vrm);
 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);   /* for ISA devices */
 
-#define SENSOR_DEV_ATTR_IN(ix) \
-&sensor_dev_attr_in##ix##_input.dev_attr.attr, \
-&sensor_dev_attr_in##ix##_min.dev_attr.attr, \
-&sensor_dev_attr_in##ix##_max.dev_attr.attr, \
-&sensor_dev_attr_in##ix##_alarm.dev_attr.attr
-
-/* These attributes are read-writeable only if the chip is *not* locked */
-#define SENSOR_DEV_ATTR_TEMP_LOCK(ix) \
-&sensor_dev_attr_temp##ix##_offset.dev_attr.attr
-
-#define SENSOR_DEV_ATTR_TEMP(ix) \
-SENSOR_DEV_ATTR_TEMP_LOCK(ix), \
-&sensor_dev_attr_temp##ix##_input.dev_attr.attr, \
-&sensor_dev_attr_temp##ix##_min.dev_attr.attr, \
-&sensor_dev_attr_temp##ix##_max.dev_attr.attr, \
-&sensor_dev_attr_temp##ix##_alarm.dev_attr.attr, \
-&sensor_dev_attr_temp##ix##_fault.dev_attr.attr
-
-/* These attributes are read-writeable only if the chip is *not* locked */
-#define SENSOR_DEV_ATTR_ZONE_LOCK(ix) \
-&sensor_dev_attr_zone##ix##_auto_point1_temp_hyst.dev_attr.attr, \
-&sensor_dev_attr_zone##ix##_auto_point1_temp.dev_attr.attr, \
-&sensor_dev_attr_zone##ix##_auto_point2_temp.dev_attr.attr, \
-&sensor_dev_attr_zone##ix##_auto_point3_temp.dev_attr.attr
-
-#define SENSOR_DEV_ATTR_ZONE(ix) \
-SENSOR_DEV_ATTR_ZONE_LOCK(ix), \
-&sensor_dev_attr_zone##ix##_auto_channels_temp.dev_attr.attr
-
-#define SENSOR_DEV_ATTR_FAN_1TO4(ix) \
-&sensor_dev_attr_fan##ix##_input.dev_attr.attr, \
-&sensor_dev_attr_fan##ix##_min.dev_attr.attr, \
-&sensor_dev_attr_fan##ix##_alarm.dev_attr.attr, \
-&sensor_dev_attr_fan##ix##_type.dev_attr.attr
-
-#define SENSOR_DEV_ATTR_FAN_5TO6(ix) \
-&sensor_dev_attr_fan##ix##_input.dev_attr.attr, \
-&sensor_dev_attr_fan##ix##_min.dev_attr.attr, \
-&sensor_dev_attr_fan##ix##_alarm.dev_attr.attr, \
-&sensor_dev_attr_fan##ix##_max.dev_attr.attr
-
-/* These attributes are read-writeable only if the chip is *not* locked */
-#define SENSOR_DEV_ATTR_PWM_1TO3_LOCK(ix) \
-&sensor_dev_attr_pwm##ix##_freq.dev_attr.attr, \
-&sensor_dev_attr_pwm##ix##_enable.dev_attr.attr, \
-&sensor_dev_attr_pwm##ix##_ramp_rate.dev_attr.attr, \
-&sensor_dev_attr_pwm##ix##_auto_channels_zone.dev_attr.attr, \
-&sensor_dev_attr_pwm##ix##_auto_pwm_min.dev_attr.attr, \
-&sensor_dev_attr_pwm##ix##_auto_point1_pwm.dev_attr.attr
-
-#define SENSOR_DEV_ATTR_PWM_1TO3(ix) \
-SENSOR_DEV_ATTR_PWM_1TO3_LOCK(ix), \
-&sensor_dev_attr_pwm##ix.dev_attr.attr, \
-&sensor_dev_attr_pwm##ix##_auto_point2_pwm.dev_attr.attr
-
-/* These attributes are read-writeable only if the chip is *not* locked */
-#define SENSOR_DEV_ATTR_PWM_5TO6_LOCK(ix) \
-&sensor_dev_attr_pwm##ix.dev_attr.attr, \
-&sensor_dev_attr_pwm##ix##_freq.dev_attr.attr
-
-#define SENSOR_DEV_ATTR_PWM_5TO6(ix) \
-SENSOR_DEV_ATTR_PWM_5TO6_LOCK(ix), \
-&sensor_dev_attr_pwm##ix##_enable.dev_attr.attr
-
 /* This struct holds all the attributes that are always present and need to be
  * created unconditionally. The attributes that need modification of their
  * permissions are created read-only and write permissions are added or removed
  * on the fly when required */
 static struct attribute *dme1737_attr[] ={
         /* Voltages */
-        SENSOR_DEV_ATTR_IN(0),
-        SENSOR_DEV_ATTR_IN(1),
-        SENSOR_DEV_ATTR_IN(2),
-        SENSOR_DEV_ATTR_IN(3),
-        SENSOR_DEV_ATTR_IN(4),
-        SENSOR_DEV_ATTR_IN(5),
-        SENSOR_DEV_ATTR_IN(6),
+        &sensor_dev_attr_in0_input.dev_attr.attr,
+        &sensor_dev_attr_in0_min.dev_attr.attr,
+        &sensor_dev_attr_in0_max.dev_attr.attr,
+        &sensor_dev_attr_in0_alarm.dev_attr.attr,
+        &sensor_dev_attr_in1_input.dev_attr.attr,
+        &sensor_dev_attr_in1_min.dev_attr.attr,
+        &sensor_dev_attr_in1_max.dev_attr.attr,
+        &sensor_dev_attr_in1_alarm.dev_attr.attr,
+        &sensor_dev_attr_in2_input.dev_attr.attr,
+        &sensor_dev_attr_in2_min.dev_attr.attr,
+        &sensor_dev_attr_in2_max.dev_attr.attr,
+        &sensor_dev_attr_in2_alarm.dev_attr.attr,
+        &sensor_dev_attr_in3_input.dev_attr.attr,
+        &sensor_dev_attr_in3_min.dev_attr.attr,
+        &sensor_dev_attr_in3_max.dev_attr.attr,
+        &sensor_dev_attr_in3_alarm.dev_attr.attr,
+        &sensor_dev_attr_in4_input.dev_attr.attr,
+        &sensor_dev_attr_in4_min.dev_attr.attr,
+        &sensor_dev_attr_in4_max.dev_attr.attr,
+        &sensor_dev_attr_in4_alarm.dev_attr.attr,
+        &sensor_dev_attr_in5_input.dev_attr.attr,
+        &sensor_dev_attr_in5_min.dev_attr.attr,
+        &sensor_dev_attr_in5_max.dev_attr.attr,
+        &sensor_dev_attr_in5_alarm.dev_attr.attr,
+        &sensor_dev_attr_in6_input.dev_attr.attr,
+        &sensor_dev_attr_in6_min.dev_attr.attr,
+        &sensor_dev_attr_in6_max.dev_attr.attr,
+        &sensor_dev_attr_in6_alarm.dev_attr.attr,
         /* Temperatures */
-        SENSOR_DEV_ATTR_TEMP(1),
-        SENSOR_DEV_ATTR_TEMP(2),
-        SENSOR_DEV_ATTR_TEMP(3),
+        &sensor_dev_attr_temp1_input.dev_attr.attr,
+        &sensor_dev_attr_temp1_min.dev_attr.attr,
+        &sensor_dev_attr_temp1_max.dev_attr.attr,
+        &sensor_dev_attr_temp1_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp1_fault.dev_attr.attr,
+        &sensor_dev_attr_temp2_input.dev_attr.attr,
+        &sensor_dev_attr_temp2_min.dev_attr.attr,
+        &sensor_dev_attr_temp2_max.dev_attr.attr,
+        &sensor_dev_attr_temp2_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp2_fault.dev_attr.attr,
+        &sensor_dev_attr_temp3_input.dev_attr.attr,
+        &sensor_dev_attr_temp3_min.dev_attr.attr,
+        &sensor_dev_attr_temp3_max.dev_attr.attr,
+        &sensor_dev_attr_temp3_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp3_fault.dev_attr.attr,
         /* Zones */
-        SENSOR_DEV_ATTR_ZONE(1),
-        SENSOR_DEV_ATTR_ZONE(2),
-        SENSOR_DEV_ATTR_ZONE(3),
+        &sensor_dev_attr_zone1_auto_point1_temp.dev_attr.attr,
+        &sensor_dev_attr_zone1_auto_point2_temp.dev_attr.attr,
+        &sensor_dev_attr_zone1_auto_point3_temp.dev_attr.attr,
+        &sensor_dev_attr_zone1_auto_channels_temp.dev_attr.attr,
+        &sensor_dev_attr_zone2_auto_point1_temp.dev_attr.attr,
+        &sensor_dev_attr_zone2_auto_point2_temp.dev_attr.attr,
+        &sensor_dev_attr_zone2_auto_point3_temp.dev_attr.attr,
+        &sensor_dev_attr_zone2_auto_channels_temp.dev_attr.attr,
+        &sensor_dev_attr_zone3_auto_point1_temp.dev_attr.attr,
+        &sensor_dev_attr_zone3_auto_point2_temp.dev_attr.attr,
+        &sensor_dev_attr_zone3_auto_point3_temp.dev_attr.attr,
+        &sensor_dev_attr_zone3_auto_channels_temp.dev_attr.attr,
+        NULL
+};
+
+static const struct attribute_group dme1737_group = {
+        .attrs = dme1737_attr,
+};
+
+/* The following struct holds misc attributes, which are not available in all
+ * chips. Their creation depends on the chip type which is determined during
+ * module load. */
+static struct attribute *dme1737_misc_attr[] = {
+        /* Temperatures */
+        &sensor_dev_attr_temp1_offset.dev_attr.attr,
+        &sensor_dev_attr_temp2_offset.dev_attr.attr,
+        &sensor_dev_attr_temp3_offset.dev_attr.attr,
+        /* Zones */
+        &sensor_dev_attr_zone1_auto_point1_temp_hyst.dev_attr.attr,
+        &sensor_dev_attr_zone2_auto_point1_temp_hyst.dev_attr.attr,
+        &sensor_dev_attr_zone3_auto_point1_temp_hyst.dev_attr.attr,
         /* Misc */
         &dev_attr_vrm.attr,
         &dev_attr_cpu0_vid.attr,
         NULL
 };
 
-static const struct attribute_group dme1737_group = {
-        .attrs = dme1737_attr,
+static const struct attribute_group dme1737_misc_group = {
+        .attrs = dme1737_misc_attr,
 };
 
 /* The following structs hold the PWM attributes, some of which are optional.
  * Their creation depends on the chip configuration which is determined during
  * module load. */
-static struct attribute *dme1737_attr_pwm1[] = {
-        SENSOR_DEV_ATTR_PWM_1TO3(1),
+static struct attribute *dme1737_pwm1_attr[] = {
+        &sensor_dev_attr_pwm1.dev_attr.attr,
+        &sensor_dev_attr_pwm1_freq.dev_attr.attr,
+        &sensor_dev_attr_pwm1_enable.dev_attr.attr,
+        &sensor_dev_attr_pwm1_ramp_rate.dev_attr.attr,
+        &sensor_dev_attr_pwm1_auto_channels_zone.dev_attr.attr,
+        &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
+        &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
         NULL
 };
-static struct attribute *dme1737_attr_pwm2[] = {
-        SENSOR_DEV_ATTR_PWM_1TO3(2),
+static struct attribute *dme1737_pwm2_attr[] = {
+        &sensor_dev_attr_pwm2.dev_attr.attr,
+        &sensor_dev_attr_pwm2_freq.dev_attr.attr,
+        &sensor_dev_attr_pwm2_enable.dev_attr.attr,
+        &sensor_dev_attr_pwm2_ramp_rate.dev_attr.attr,
+        &sensor_dev_attr_pwm2_auto_channels_zone.dev_attr.attr,
+        &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
+        &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr,
         NULL
 };
-static struct attribute *dme1737_attr_pwm3[] = {
-        SENSOR_DEV_ATTR_PWM_1TO3(3),
+static struct attribute *dme1737_pwm3_attr[] = {
+        &sensor_dev_attr_pwm3.dev_attr.attr,
+        &sensor_dev_attr_pwm3_freq.dev_attr.attr,
+        &sensor_dev_attr_pwm3_enable.dev_attr.attr,
+        &sensor_dev_attr_pwm3_ramp_rate.dev_attr.attr,
+        &sensor_dev_attr_pwm3_auto_channels_zone.dev_attr.attr,
+        &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,
+        &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr,
         NULL
 };
-static struct attribute *dme1737_attr_pwm5[] = {
-        SENSOR_DEV_ATTR_PWM_5TO6(5),
+static struct attribute *dme1737_pwm5_attr[] = {
+        &sensor_dev_attr_pwm5.dev_attr.attr,
+        &sensor_dev_attr_pwm5_freq.dev_attr.attr,
+        &sensor_dev_attr_pwm5_enable.dev_attr.attr,
         NULL
 };
-static struct attribute *dme1737_attr_pwm6[] = {
-        SENSOR_DEV_ATTR_PWM_5TO6(6),
+static struct attribute *dme1737_pwm6_attr[] = {
+        &sensor_dev_attr_pwm6.dev_attr.attr,
+        &sensor_dev_attr_pwm6_freq.dev_attr.attr,
+        &sensor_dev_attr_pwm6_enable.dev_attr.attr,
         NULL
 };
 
 static const struct attribute_group dme1737_pwm_group[] = {
-        { .attrs = dme1737_attr_pwm1 },
-        { .attrs = dme1737_attr_pwm2 },
-        { .attrs = dme1737_attr_pwm3 },
+        { .attrs = dme1737_pwm1_attr },
+        { .attrs = dme1737_pwm2_attr },
+        { .attrs = dme1737_pwm3_attr },
         { .attrs = NULL },
-        { .attrs = dme1737_attr_pwm5 },
-        { .attrs = dme1737_attr_pwm6 },
+        { .attrs = dme1737_pwm5_attr },
+        { .attrs = dme1737_pwm6_attr },
+};
+
+/* The following struct holds misc PWM attributes, which are not available in
+ * all chips. Their creation depends on the chip type which is determined
+ * during module load. */
+static struct attribute *dme1737_pwm_misc_attr[] = {
+        &sensor_dev_attr_pwm1_auto_pwm_min.dev_attr.attr,
+        &sensor_dev_attr_pwm2_auto_pwm_min.dev_attr.attr,
+        &sensor_dev_attr_pwm3_auto_pwm_min.dev_attr.attr,
 };
 
 /* The following structs hold the fan attributes, some of which are optional.
  * Their creation depends on the chip configuration which is determined during
  * module load. */
-static struct attribute *dme1737_attr_fan1[] = {
-        SENSOR_DEV_ATTR_FAN_1TO4(1),
+static struct attribute *dme1737_fan1_attr[] = {
+        &sensor_dev_attr_fan1_input.dev_attr.attr,
+        &sensor_dev_attr_fan1_min.dev_attr.attr,
+        &sensor_dev_attr_fan1_alarm.dev_attr.attr,
+        &sensor_dev_attr_fan1_type.dev_attr.attr,
         NULL
 };
-static struct attribute *dme1737_attr_fan2[] = {
-        SENSOR_DEV_ATTR_FAN_1TO4(2),
+static struct attribute *dme1737_fan2_attr[] = {
+        &sensor_dev_attr_fan2_input.dev_attr.attr,
+        &sensor_dev_attr_fan2_min.dev_attr.attr,
+        &sensor_dev_attr_fan2_alarm.dev_attr.attr,
+        &sensor_dev_attr_fan2_type.dev_attr.attr,
         NULL
 };
-static struct attribute *dme1737_attr_fan3[] = {
-        SENSOR_DEV_ATTR_FAN_1TO4(3),
+static struct attribute *dme1737_fan3_attr[] = {
+        &sensor_dev_attr_fan3_input.dev_attr.attr,
+        &sensor_dev_attr_fan3_min.dev_attr.attr,
+        &sensor_dev_attr_fan3_alarm.dev_attr.attr,
+        &sensor_dev_attr_fan3_type.dev_attr.attr,
         NULL
 };
-static struct attribute *dme1737_attr_fan4[] = {
-        SENSOR_DEV_ATTR_FAN_1TO4(4),
+static struct attribute *dme1737_fan4_attr[] = {
+        &sensor_dev_attr_fan4_input.dev_attr.attr,
+        &sensor_dev_attr_fan4_min.dev_attr.attr,
+        &sensor_dev_attr_fan4_alarm.dev_attr.attr,
+        &sensor_dev_attr_fan4_type.dev_attr.attr,
         NULL
 };
-static struct attribute *dme1737_attr_fan5[] = {
-        SENSOR_DEV_ATTR_FAN_5TO6(5),
+static struct attribute *dme1737_fan5_attr[] = {
+        &sensor_dev_attr_fan5_input.dev_attr.attr,
+        &sensor_dev_attr_fan5_min.dev_attr.attr,
+        &sensor_dev_attr_fan5_alarm.dev_attr.attr,
+        &sensor_dev_attr_fan5_max.dev_attr.attr,
         NULL
 };
-static struct attribute *dme1737_attr_fan6[] = {
-        SENSOR_DEV_ATTR_FAN_5TO6(6),
+static struct attribute *dme1737_fan6_attr[] = {
+        &sensor_dev_attr_fan6_input.dev_attr.attr,
+        &sensor_dev_attr_fan6_min.dev_attr.attr,
+        &sensor_dev_attr_fan6_alarm.dev_attr.attr,
+        &sensor_dev_attr_fan6_max.dev_attr.attr,
         NULL
 };
 
 static const struct attribute_group dme1737_fan_group[] = {
-        { .attrs = dme1737_attr_fan1 },
-        { .attrs = dme1737_attr_fan2 },
-        { .attrs = dme1737_attr_fan3 },
-        { .attrs = dme1737_attr_fan4 },
-        { .attrs = dme1737_attr_fan5 },
-        { .attrs = dme1737_attr_fan6 },
+        { .attrs = dme1737_fan1_attr },
+        { .attrs = dme1737_fan2_attr },
+        { .attrs = dme1737_fan3_attr },
+        { .attrs = dme1737_fan4_attr },
+        { .attrs = dme1737_fan5_attr },
+        { .attrs = dme1737_fan6_attr },
 };
 
-/* The permissions of all of the following attributes are changed to read-
+/* The permissions of the following zone attributes are changed to read-
  * writeable if the chip is *not* locked. Otherwise they stay read-only. */
-static struct attribute *dme1737_attr_lock[] = {
-        /* Temperatures */
-        SENSOR_DEV_ATTR_TEMP_LOCK(1),
-        SENSOR_DEV_ATTR_TEMP_LOCK(2),
-        SENSOR_DEV_ATTR_TEMP_LOCK(3),
-        /* Zones */
-        SENSOR_DEV_ATTR_ZONE_LOCK(1),
-        SENSOR_DEV_ATTR_ZONE_LOCK(2),
-        SENSOR_DEV_ATTR_ZONE_LOCK(3),
+static struct attribute *dme1737_zone_chmod_attr[] = {
+        &sensor_dev_attr_zone1_auto_point1_temp.dev_attr.attr,
+        &sensor_dev_attr_zone1_auto_point2_temp.dev_attr.attr,
+        &sensor_dev_attr_zone1_auto_point3_temp.dev_attr.attr,
+        &sensor_dev_attr_zone2_auto_point1_temp.dev_attr.attr,
+        &sensor_dev_attr_zone2_auto_point2_temp.dev_attr.attr,
+        &sensor_dev_attr_zone2_auto_point3_temp.dev_attr.attr,
+        &sensor_dev_attr_zone3_auto_point1_temp.dev_attr.attr,
+        &sensor_dev_attr_zone3_auto_point2_temp.dev_attr.attr,
+        &sensor_dev_attr_zone3_auto_point3_temp.dev_attr.attr,
         NULL
 };
 
-static const struct attribute_group dme1737_lock_group = {
-        .attrs = dme1737_attr_lock,
+static const struct attribute_group dme1737_zone_chmod_group = {
+        .attrs = dme1737_zone_chmod_attr,
 };
 
 /* The permissions of the following PWM attributes are changed to read-
  * writeable if the chip is *not* locked and the respective PWM is available.
  * Otherwise they stay read-only. */
-static struct attribute *dme1737_attr_pwm1_lock[] = {
-        SENSOR_DEV_ATTR_PWM_1TO3_LOCK(1),
+static struct attribute *dme1737_pwm1_chmod_attr[] = {
+        &sensor_dev_attr_pwm1_freq.dev_attr.attr,
+        &sensor_dev_attr_pwm1_enable.dev_attr.attr,
+        &sensor_dev_attr_pwm1_ramp_rate.dev_attr.attr,
+        &sensor_dev_attr_pwm1_auto_channels_zone.dev_attr.attr,
+        &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
         NULL
 };
-static struct attribute *dme1737_attr_pwm2_lock[] = {
-        SENSOR_DEV_ATTR_PWM_1TO3_LOCK(2),
+static struct attribute *dme1737_pwm2_chmod_attr[] = {
+        &sensor_dev_attr_pwm2_freq.dev_attr.attr,
+        &sensor_dev_attr_pwm2_enable.dev_attr.attr,
+        &sensor_dev_attr_pwm2_ramp_rate.dev_attr.attr,
+        &sensor_dev_attr_pwm2_auto_channels_zone.dev_attr.attr,
+        &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
         NULL
 };
-static struct attribute *dme1737_attr_pwm3_lock[] = {
-        SENSOR_DEV_ATTR_PWM_1TO3_LOCK(3),
+static struct attribute *dme1737_pwm3_chmod_attr[] = {
+        &sensor_dev_attr_pwm3_freq.dev_attr.attr,
+        &sensor_dev_attr_pwm3_enable.dev_attr.attr,
+        &sensor_dev_attr_pwm3_ramp_rate.dev_attr.attr,
+        &sensor_dev_attr_pwm3_auto_channels_zone.dev_attr.attr,
+        &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,
         NULL
 };
-static struct attribute *dme1737_attr_pwm5_lock[] = {
-        SENSOR_DEV_ATTR_PWM_5TO6_LOCK(5),
+static struct attribute *dme1737_pwm5_chmod_attr[] = {
+        &sensor_dev_attr_pwm5.dev_attr.attr,
+        &sensor_dev_attr_pwm5_freq.dev_attr.attr,
         NULL
 };
-static struct attribute *dme1737_attr_pwm6_lock[] = {
-        SENSOR_DEV_ATTR_PWM_5TO6_LOCK(6),
+static struct attribute *dme1737_pwm6_chmod_attr[] = {
+        &sensor_dev_attr_pwm6.dev_attr.attr,
+        &sensor_dev_attr_pwm6_freq.dev_attr.attr,
         NULL
 };
 
-static const struct attribute_group dme1737_pwm_lock_group[] = {
-        { .attrs = dme1737_attr_pwm1_lock },
-        { .attrs = dme1737_attr_pwm2_lock },
-        { .attrs = dme1737_attr_pwm3_lock },
+static const struct attribute_group dme1737_pwm_chmod_group[] = {
+        { .attrs = dme1737_pwm1_chmod_attr },
+        { .attrs = dme1737_pwm2_chmod_attr },
+        { .attrs = dme1737_pwm3_chmod_attr },
         { .attrs = NULL },
-        { .attrs = dme1737_attr_pwm5_lock },
-        { .attrs = dme1737_attr_pwm6_lock },
+        { .attrs = dme1737_pwm5_chmod_attr },
+        { .attrs = dme1737_pwm6_chmod_attr },
 };
 
 /* Pwm[1-3] are read-writeable if the associated pwm is in manual mode and the
  * chip is not locked. Otherwise they are read-only. */
-static struct attribute *dme1737_attr_pwm[] = {
+static struct attribute *dme1737_pwm_chmod_attr[] = {
         &sensor_dev_attr_pwm1.dev_attr.attr,
         &sensor_dev_attr_pwm2.dev_attr.attr,
         &sensor_dev_attr_pwm3.dev_attr.attr,
@@ -1809,12 +1891,20 @@ static void dme1737_remove_files(struct device *dev)
                 if (data->has_pwm & (1 << ix)) {
                         sysfs_remove_group(&dev->kobj,
                                            &dme1737_pwm_group[ix]);
+                        if (data->type != sch5027 && ix < 3) {
+                                sysfs_remove_file(&dev->kobj,
+                                                  dme1737_pwm_misc_attr[ix]);
+                        }
                 }
         }
 
+        if (data->type != sch5027) {
+                sysfs_remove_group(&dev->kobj, &dme1737_misc_group);
+        }
+
         sysfs_remove_group(&dev->kobj, &dme1737_group);
 
-        if (!data->client.driver) {
+        if (!data->client) {
                 sysfs_remove_file(&dev->kobj, &dev_attr_name.attr);
         }
 }
@@ -1825,7 +1915,7 @@ static int dme1737_create_files(struct device *dev)
         int err, ix;
 
         /* Create a name attribute for ISA devices */
-        if (!data->client.driver &&
+        if (!data->client &&
             (err = sysfs_create_file(&dev->kobj, &dev_attr_name.attr))) {
                 goto exit;
         }
@@ -1835,6 +1925,13 @@ static int dme1737_create_files(struct device *dev)
                 goto exit_remove;
         }
 
+        /* Create misc sysfs attributes */
+        if ((data->type != sch5027) &&
+            (err = sysfs_create_group(&dev->kobj,
+                                      &dme1737_misc_group))) {
+                goto exit_remove;
+        }
+
         /* Create fan sysfs attributes */
         for (ix = 0; ix < ARRAY_SIZE(dme1737_fan_group); ix++) {
                 if (data->has_fan & (1 << ix)) {
@@ -1852,6 +1949,11 @@ static int dme1737_create_files(struct device *dev)
                                                 &dme1737_pwm_group[ix]))) {
                                 goto exit_remove;
                         }
+                        if (data->type != sch5027 && ix < 3 &&
+                            (err = sysfs_create_file(&dev->kobj,
+                                                dme1737_pwm_misc_attr[ix]))) {
+                                goto exit_remove;
+                        }
                 }
         }
 
@@ -1861,16 +1963,27 @@ static int dme1737_create_files(struct device *dev)
                 dev_info(dev, "Device is locked. Some attributes "
                          "will be read-only.\n");
         } else {
-                /* Change permissions of standard attributes */
-                dme1737_chmod_group(dev, &dme1737_lock_group,
+                /* Change permissions of zone sysfs attributes */
+                dme1737_chmod_group(dev, &dme1737_zone_chmod_group,
                                     S_IRUGO | S_IWUSR);
 
-                /* Change permissions of PWM attributes */
-                for (ix = 0; ix < ARRAY_SIZE(dme1737_pwm_lock_group); ix++) {
+                /* Change permissions of misc sysfs attributes */
+                if (data->type != sch5027) {
+                        dme1737_chmod_group(dev, &dme1737_misc_group,
+                                            S_IRUGO | S_IWUSR);
+                }
+
+                /* Change permissions of PWM sysfs attributes */
+                for (ix = 0; ix < ARRAY_SIZE(dme1737_pwm_chmod_group); ix++) {
                         if (data->has_pwm & (1 << ix)) {
                                 dme1737_chmod_group(dev,
-                                                &dme1737_pwm_lock_group[ix],
+                                                &dme1737_pwm_chmod_group[ix],
+                                                S_IRUGO | S_IWUSR);
+                                if (data->type != sch5027 && ix < 3) {
+                                        dme1737_chmod_file(dev,
+                                                dme1737_pwm_misc_attr[ix],
                                                 S_IRUGO | S_IWUSR);
+                                }
                         }
                 }
 
@@ -1879,7 +1992,7 @@ static int dme1737_create_files(struct device *dev)
                         if ((data->has_pwm & (1 << ix)) &&
                             (PWM_EN_FROM_REG(data->pwm_config[ix]) == 1)) {
                                 dme1737_chmod_file(dev,
-                                                dme1737_attr_pwm[ix],
+                                                dme1737_pwm_chmod_attr[ix],
                                                 S_IRUGO | S_IWUSR);
                         }
                 }
@@ -1896,11 +2009,14 @@ exit:
 static int dme1737_init_device(struct device *dev)
 {
         struct dme1737_data *data = dev_get_drvdata(dev);
-        struct i2c_client *client = &data->client;
+        struct i2c_client *client = data->client;
         int ix;
         u8 reg;
 
-        data->config = dme1737_read(client, DME1737_REG_CONFIG);
+        /* Point to the right nominal voltages array */
+        data->in_nominal = IN_NOMINAL(data->type);
+
+        data->config = dme1737_read(data, DME1737_REG_CONFIG);
         /* Inform if part is not monitoring/started */
         if (!(data->config & 0x01)) {
                 if (!force_start) {
@@ -1912,7 +2028,7 @@ static int dme1737_init_device(struct device *dev)
 
                 /* Force monitoring */
                 data->config |= 0x01;
-                dme1737_write(client, DME1737_REG_CONFIG, data->config);
+                dme1737_write(data, DME1737_REG_CONFIG, data->config);
         }
         /* Inform if part is not ready */
         if (!(data->config & 0x04)) {
@@ -1921,8 +2037,8 @@ static int dme1737_init_device(struct device *dev)
         }
 
         /* Determine which optional fan and pwm features are enabled/present */
-        if (client->driver) {   /* I2C chip */
-                data->config2 = dme1737_read(client, DME1737_REG_CONFIG2);
+        if (client) {   /* I2C chip */
+                data->config2 = dme1737_read(data, DME1737_REG_CONFIG2);
                 /* Check if optional fan3 input is enabled */
                 if (data->config2 & 0x04) {
                         data->has_fan |= (1 << 2);
@@ -1931,7 +2047,7 @@ static int dme1737_init_device(struct device *dev)
                 /* Fan4 and pwm3 are only available if the client's I2C address
                  * is the default 0x2e. Otherwise the I/Os associated with
                  * these functions are used for addr enable/select. */
-                if (data->client.addr == 0x2e) {
+                if (client->addr == 0x2e) {
                         data->has_fan |= (1 << 3);
                         data->has_pwm |= (1 << 2);
                 }
@@ -1966,16 +2082,16 @@ static int dme1737_init_device(struct device *dev)
                  (data->has_fan & (1 << 4)) ? "yes" : "no",
                  (data->has_fan & (1 << 5)) ? "yes" : "no");
 
-        reg = dme1737_read(client, DME1737_REG_TACH_PWM);
+        reg = dme1737_read(data, DME1737_REG_TACH_PWM);
         /* Inform if fan-to-pwm mapping differs from the default */
-        if (client->driver && reg != 0xa4) {   /* I2C chip */
+        if (client && reg != 0xa4) {   /* I2C chip */
                 dev_warn(dev, "Non-standard fan to pwm mapping: "
                          "fan1->pwm%d, fan2->pwm%d, fan3->pwm%d, "
                          "fan4->pwm%d. Please report to the driver "
                          "maintainer.\n",
                          (reg & 0x03) + 1, ((reg >> 2) & 0x03) + 1,
                          ((reg >> 4) & 0x03) + 1, ((reg >> 6) & 0x03) + 1);
-        } else if (!client->driver && reg != 0x24) {   /* ISA chip */
+        } else if (!client && reg != 0x24) {   /* ISA chip */
                 dev_warn(dev, "Non-standard fan to pwm mapping: "
                          "fan1->pwm%d, fan2->pwm%d, fan3->pwm%d. "
                          "Please report to the driver maintainer.\n",
@@ -1988,7 +2104,7 @@ static int dme1737_init_device(struct device *dev)
          * disabled). */
         if (!(data->config & 0x02)) {
                 for (ix = 0; ix < 3; ix++) {
-                        data->pwm_config[ix] = dme1737_read(client,
+                        data->pwm_config[ix] = dme1737_read(data,
                                                 DME1737_REG_PWM_CONFIG(ix));
                         if ((data->has_pwm & (1 << ix)) &&
                             (PWM_EN_FROM_REG(data->pwm_config[ix]) == -1)) {
@@ -1996,8 +2112,8 @@ static int dme1737_init_device(struct device *dev)
                                          "manual mode.\n", ix + 1);
                                 data->pwm_config[ix] = PWM_EN_TO_REG(1,
                                                         data->pwm_config[ix]);
-                                dme1737_write(client, DME1737_REG_PWM(ix), 0);
-                                dme1737_write(client,
+                                dme1737_write(data, DME1737_REG_PWM(ix), 0);
+                                dme1737_write(data,
                                               DME1737_REG_PWM_CONFIG(ix),
                                               data->pwm_config[ix]);
                         }
@@ -2010,7 +2126,9 @@ static int dme1737_init_device(struct device *dev)
         data->pwm_acz[2] = 4;   /* pwm3 -> zone3 */
 
         /* Set VRM */
-        data->vrm = vid_which_vrm();
+        if (data->type != sch5027) {
+                data->vrm = vid_which_vrm();
+        }
 
         return 0;
 }
@@ -2029,9 +2147,10 @@ static int dme1737_i2c_get_features(int sio_cip, struct dme1737_data *data)
         dme1737_sio_enter(sio_cip);
 
         /* Check device ID
-         * The DME1737 can return either 0x78 or 0x77 as its device ID. */
+         * The DME1737 can return either 0x78 or 0x77 as its device ID.
+         * The SCH5027 returns 0x89 as its device ID. */
         reg = force_id ? force_id : dme1737_sio_inb(sio_cip, 0x20);
-        if (!(reg == 0x77 || reg == 0x78)) {
+        if (!(reg == 0x77 || reg == 0x78 || reg == 0x89)) {
                 err = -ENODEV;
                 goto exit;
         }
@@ -2068,71 +2187,80 @@ exit:
         return err;
 }
 
-static int dme1737_i2c_detect(struct i2c_adapter *adapter, int address,
-                              int kind)
+/* Return 0 if detection is successful, -ENODEV otherwise */
+static int dme1737_i2c_detect(struct i2c_client *client, int kind,
+                              struct i2c_board_info *info)
 {
+        struct i2c_adapter *adapter = client->adapter;
+        struct device *dev = &adapter->dev;
         u8 company, verstep = 0;
-        struct i2c_client *client;
-        struct dme1737_data *data;
-        struct device *dev;
-        int err = 0;
         const char *name;
 
         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
-                goto exit;
-        }
-
-        if (!(data = kzalloc(sizeof(struct dme1737_data), GFP_KERNEL))) {
-                err = -ENOMEM;
-                goto exit;
+                return -ENODEV;
         }
 
-        client = &data->client;
-        i2c_set_clientdata(client, data);
-        client->addr = address;
-        client->adapter = adapter;
-        client->driver = &dme1737_i2c_driver;
-        dev = &client->dev;
-
         /* A negative kind means that the driver was loaded with no force
          * parameter (default), so we must identify the chip. */
         if (kind < 0) {
-                company = dme1737_read(client, DME1737_REG_COMPANY);
-                verstep = dme1737_read(client, DME1737_REG_VERSTEP);
-
-                if (!((company == DME1737_COMPANY_SMSC) &&
-                      ((verstep & DME1737_VERSTEP_MASK) == DME1737_VERSTEP))) {
-                        err = -ENODEV;
-                        goto exit_kfree;
+                company = i2c_smbus_read_byte_data(client, DME1737_REG_COMPANY);
+                verstep = i2c_smbus_read_byte_data(client, DME1737_REG_VERSTEP);
+
+                if (company == DME1737_COMPANY_SMSC &&
+                    (verstep & DME1737_VERSTEP_MASK) == DME1737_VERSTEP) {
+                        kind = dme1737;
+                } else if (company == DME1737_COMPANY_SMSC &&
+                           verstep == SCH5027_VERSTEP) {
+                        kind = sch5027;
+                } else {
+                        return -ENODEV;
                 }
         }
 
-        kind = dme1737;
-        name = "dme1737";
+        if (kind == sch5027) {
+                name = "sch5027";
+        } else {
+                kind = dme1737;
+                name = "dme1737";
+        }
 
-        /* Fill in the remaining client fields and put it into the global
-         * list */
-        strlcpy(client->name, name, I2C_NAME_SIZE);
-        mutex_init(&data->update_lock);
+        dev_info(dev, "Found a %s chip at 0x%02x (rev 0x%02x).\n",
+                 kind == sch5027 ? "SCH5027" : "DME1737", client->addr,
+                 verstep);
+        strlcpy(info->type, name, I2C_NAME_SIZE);
 
-        /* Tell the I2C layer a new client has arrived */
-        if ((err = i2c_attach_client(client))) {
-                goto exit_kfree;
+        return 0;
+}
+
+static int dme1737_i2c_probe(struct i2c_client *client,
+                             const struct i2c_device_id *id)
+{
+        struct dme1737_data *data;
+        struct device *dev = &client->dev;
+        int err;
+
+        data = kzalloc(sizeof(struct dme1737_data), GFP_KERNEL);
+        if (!data) {
+                err = -ENOMEM;
+                goto exit;
         }
 
-        dev_info(dev, "Found a DME1737 chip at 0x%02x (rev 0x%02x).\n",
-                 client->addr, verstep);
+        i2c_set_clientdata(client, data);
+        data->type = id->driver_data;
+        data->client = client;
+        data->name = client->name;
+        mutex_init(&data->update_lock);
 
         /* Initialize the DME1737 chip */
         if ((err = dme1737_init_device(dev))) {
                 dev_err(dev, "Failed to initialize device.\n");
-                goto exit_detach;
+                goto exit_kfree;
         }
 
         /* Create sysfs files */
         if ((err = dme1737_create_files(dev))) {
                 dev_err(dev, "Failed to create sysfs files.\n");
-                goto exit_detach;
+                goto exit_kfree;
         }
 
         /* Register device */
@@ -2147,45 +2275,40 @@ static int dme1737_i2c_detect(struct i2c_adapter *adapter, int address,
 
 exit_remove:
         dme1737_remove_files(dev);
-exit_detach:
-        i2c_detach_client(client);
 exit_kfree:
         kfree(data);
 exit:
         return err;
 }
 
-static int dme1737_i2c_attach_adapter(struct i2c_adapter *adapter)
-{
-        if (!(adapter->class & I2C_CLASS_HWMON)) {
-                return 0;
-        }
-
-        return i2c_probe(adapter, &addr_data, dme1737_i2c_detect);
-}
-
-static int dme1737_i2c_detach_client(struct i2c_client *client)
+static int dme1737_i2c_remove(struct i2c_client *client)
 {
         struct dme1737_data *data = i2c_get_clientdata(client);
-        int err;
 
         hwmon_device_unregister(data->hwmon_dev);
         dme1737_remove_files(&client->dev);
 
-        if ((err = i2c_detach_client(client))) {
-                return err;
-        }
-
         kfree(data);
         return 0;
 }
 
+static const struct i2c_device_id dme1737_id[] = {
+        { "dme1737", dme1737 },
+        { "sch5027", sch5027 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, dme1737_id);
+
 static struct i2c_driver dme1737_i2c_driver = {
+        .class = I2C_CLASS_HWMON,
         .driver = {
                 .name = "dme1737",
         },
-        .attach_adapter = dme1737_i2c_attach_adapter,
-        .detach_client = dme1737_i2c_detach_client,
+        .probe = dme1737_i2c_probe,
+        .remove = dme1737_i2c_remove,
+        .id_table = dme1737_id,
+        .detect = dme1737_i2c_detect,
+        .address_data = &addr_data,
 };
 
 /* ---------------------------------------------------------------------
@@ -2269,7 +2392,6 @@ static int __devinit dme1737_isa_probe(struct platform_device *pdev)
 {
         u8 company, device;
         struct resource *res;
-        struct i2c_client *client;
         struct dme1737_data *data;
         struct device *dev = &pdev->dev;
         int err;
@@ -2288,25 +2410,27 @@ static int __devinit dme1737_isa_probe(struct platform_device *pdev)
                 goto exit_release_region;
         }
 
-        client = &data->client;
-        i2c_set_clientdata(client, data);
-        client->addr = res->start;
+        data->addr = res->start;
         platform_set_drvdata(pdev, data);
 
-        company = dme1737_read(client, DME1737_REG_COMPANY);
-        device = dme1737_read(client, DME1737_REG_DEVICE);
+        /* Skip chip detection if module is loaded with force_id parameter */
+        if (!force_id) {
+                company = dme1737_read(data, DME1737_REG_COMPANY);
+                device = dme1737_read(data, DME1737_REG_DEVICE);
 
-        if (!((company == DME1737_COMPANY_SMSC) &&
-              (device == SCH311X_DEVICE))) {
-                err = -ENODEV;
-                goto exit_kfree;
+                if (!((company == DME1737_COMPANY_SMSC) &&
+                      (device == SCH311X_DEVICE))) {
+                        err = -ENODEV;
+                        goto exit_kfree;
+                }
         }
+        data->type = sch311x;
 
         /* Fill in the remaining client fields and initialize the mutex */
-        strlcpy(client->name, "sch311x", I2C_NAME_SIZE);
+        data->name = "sch311x";
         mutex_init(&data->update_lock);
 
-        dev_info(dev, "Found a SCH311x chip at 0x%04x\n", client->addr);
+        dev_info(dev, "Found a SCH311x chip at 0x%04x\n", data->addr);
 
         /* Initialize the chip */
         if ((err = dme1737_init_device(dev))) {
@@ -2347,7 +2471,7 @@ static int __devexit dme1737_isa_remove(struct platform_device *pdev)
 
         hwmon_device_unregister(data->hwmon_dev);
         dme1737_remove_files(&pdev->dev);
-        release_region(data->client.addr, DME1737_EXTENT);
+        release_region(data->addr, DME1737_EXTENT);
         platform_set_drvdata(pdev, NULL);
         kfree(data);
 
@@ -2377,7 +2501,10 @@ static int __init dme1737_init(void)
         }
 
         if (dme1737_isa_detect(0x2e, &addr) &&
-            dme1737_isa_detect(0x4e, &addr)) {
+            dme1737_isa_detect(0x4e, &addr) &&
+            (!probe_all_addr ||
+             (dme1737_isa_detect(0x162e, &addr) &&
+              dme1737_isa_detect(0x164e, &addr)))) {
                 /* Return 0 if we didn't find an ISA device */
                 return 0;
         }
diff --git a/drivers/hwmon/f71882fg.c b/drivers/hwmon/f71882fg.c
index cbeb4984b5c7..67067e9a323e 100644
--- a/drivers/hwmon/f71882fg.c
+++ b/drivers/hwmon/f71882fg.c
@@ -87,8 +87,6 @@ static inline void superio_enter(int base);
 static inline void superio_select(int base, int ld);
 static inline void superio_exit(int base);
 
-static inline u16 fan_from_reg ( u16 reg );
-
 struct f71882fg_data {
         unsigned short addr;
         struct device *hwmon_dev;
@@ -116,10 +114,6 @@ struct f71882fg_data {
         u8      temp_diode_open;
 };
 
-static u8 f71882fg_read8(struct f71882fg_data *data, u8 reg);
-static u16 f71882fg_read16(struct f71882fg_data *data, u8 reg);
-static void f71882fg_write8(struct f71882fg_data *data, u8 reg, u8 val);
-
 /* Sysfs in*/
 static ssize_t show_in(struct device *dev, struct device_attribute *devattr,
         char *buf);
diff --git a/drivers/hwmon/hdaps.c b/drivers/hwmon/hdaps.c
index 50f22690d611..a4d92d246d52 100644
--- a/drivers/hwmon/hdaps.c
+++ b/drivers/hwmon/hdaps.c
@@ -581,6 +581,8 @@ static int __init hdaps_init(void)
         /* initialize the input class */
         idev = hdaps_idev->input;
         idev->name = "hdaps";
+        idev->phys = "isa1600/input0";
+        idev->id.bustype = BUS_ISA;
         idev->dev.parent = &pdev->dev;
         idev->evbit[0] = BIT_MASK(EV_ABS);
         input_set_abs_params(idev, ABS_X,
diff --git a/drivers/hwmon/hwmon-vid.c b/drivers/hwmon/hwmon-vid.c
index 3330667280b9..bfc296145bba 100644
--- a/drivers/hwmon/hwmon-vid.c
+++ b/drivers/hwmon/hwmon-vid.c
@@ -1,76 +1,82 @@
 /*
-    hwmon-vid.c - VID/VRM/VRD voltage conversions
-
-    Copyright (c) 2004 Rudolf Marek <r.marek@assembler.cz>
-
-    Partly imported from i2c-vid.h of the lm_sensors project
-    Copyright (c) 2002 Mark D. Studebaker <mdsxyz123@yahoo.com>
-    With assistance from Trent Piepho <xyzzy@speakeasy.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.
-*/
+ * hwmon-vid.c - VID/VRM/VRD voltage conversions
+ *
+ * Copyright (c) 2004 Rudolf Marek <r.marek@assembler.cz>
+ *
+ * Partly imported from i2c-vid.h of the lm_sensors project
+ * Copyright (c) 2002 Mark D. Studebaker <mdsxyz123@yahoo.com>
+ * With assistance from Trent Piepho <xyzzy@speakeasy.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/kernel.h>
 #include <linux/hwmon-vid.h>
 
 /*
-    Common code for decoding VID pins.
-
-    References:
-
-    For VRM 8.4 to 9.1, "VRM x.y DC-DC Converter Design Guidelines",
-    available at http://developer.intel.com/.
-
-    For VRD 10.0 and up, "VRD x.y Design Guide",
-    available at http://developer.intel.com/.
-
-    AMD Opteron processors don't follow the Intel specifications.
-    I'm going to "make up" 2.4 as the spec number for the Opterons.
-    No good reason just a mnemonic for the 24x Opteron processor
-    series.
-
-    Opteron VID encoding is:
-       00000  =  1.550 V
-       00001  =  1.525 V
-        . . . .
-       11110  =  0.800 V
-       11111  =  0.000 V (off)
-
-    The 17 specification is in fact Intel Mobile Voltage Positioning -
-    (IMVP-II). You can find more information in the datasheet of Max1718
-    http://www.maxim-ic.com/quick_view2.cfm/qv_pk/2452
-
-    The 13 specification corresponds to the Intel Pentium M series. There
-    doesn't seem to be any named specification for these. The conversion
-    tables are detailed directly in the various Pentium M datasheets:
-    http://www.intel.com/design/intarch/pentiumm/docs_pentiumm.htm
-
-    The 14 specification corresponds to Intel Core series. There
-    doesn't seem to be any named specification for these. The conversion
-    tables are detailed directly in the various Pentium Core datasheets:
-    http://www.intel.com/design/mobile/datashts/309221.htm
-
-    The 110 (VRM 11) specification corresponds to Intel Conroe based series.
-    http://www.intel.com/design/processor/applnots/313214.htm
-*/
-
-/* vrm is the VRM/VRD document version multiplied by 10.
-   val is the 4-bit or more VID code.
-   Returned value is in mV to avoid floating point in the kernel.
-   Some VID have some bits in uV scale, this is rounded to mV */
+ * Common code for decoding VID pins.
+ *
+ * References:
+ *
+ * For VRM 8.4 to 9.1, "VRM x.y DC-DC Converter Design Guidelines",
+ * available at http://developer.intel.com/.
+ *
+ * For VRD 10.0 and up, "VRD x.y Design Guide",
+ * available at http://developer.intel.com/.
+ *
+ * AMD Athlon 64 and AMD Opteron Processors, AMD Publication 26094,
+ * http://www.amd.com/us-en/assets/content_type/white_papers_and_tech_docs/26094.PDF
+ * Table 74. VID Code Voltages
+ * This corresponds to an arbitrary VRM code of 24 in the functions below.
+ * These CPU models (K8 revision <= E) have 5 VID pins. See also:
+ * Revision Guide for AMD Athlon 64 and AMD Opteron Processors, AMD Publication 25759,
+ * http://www.amd.com/us-en/assets/content_type/white_papers_and_tech_docs/25759.pdf
+ *
+ * AMD NPT Family 0Fh Processors, AMD Publication 32559,
+ * http://www.amd.com/us-en/assets/content_type/white_papers_and_tech_docs/32559.pdf
+ * Table 71. VID Code Voltages
+ * This corresponds to an arbitrary VRM code of 25 in the functions below.
+ * These CPU models (K8 revision >= F) have 6 VID pins. See also:
+ * Revision Guide for AMD NPT Family 0Fh Processors, AMD Publication 33610,
+ * http://www.amd.com/us-en/assets/content_type/white_papers_and_tech_docs/33610.pdf
+ *
+ * The 17 specification is in fact Intel Mobile Voltage Positioning -
+ * (IMVP-II). You can find more information in the datasheet of Max1718
+ * http://www.maxim-ic.com/quick_view2.cfm/qv_pk/2452
+ *
+ * The 13 specification corresponds to the Intel Pentium M series. There
+ * doesn't seem to be any named specification for these. The conversion
+ * tables are detailed directly in the various Pentium M datasheets:
+ * http://www.intel.com/design/intarch/pentiumm/docs_pentiumm.htm
+ *
+ * The 14 specification corresponds to Intel Core series. There
+ * doesn't seem to be any named specification for these. The conversion
+ * tables are detailed directly in the various Pentium Core datasheets:
+ * http://www.intel.com/design/mobile/datashts/309221.htm
+ *
+ * The 110 (VRM 11) specification corresponds to Intel Conroe based series.
+ * http://www.intel.com/design/processor/applnots/313214.htm
+ */
+
+/*
+ * vrm is the VRM/VRD document version multiplied by 10.
+ * val is the 4-bit or more VID code.
+ * Returned value is in mV to avoid floating point in the kernel.
+ * Some VID have some bits in uV scale, this is rounded to mV.
+ */
 int vid_from_reg(int val, u8 vrm)
 {
         int vid;
@@ -96,9 +102,16 @@ int vid_from_reg(int val, u8 vrm)
                 if (val < 0x02 || val > 0xb2)
                         return 0;
                 return((1600000 - (val - 2) * 6250 + 500) / 1000);
-        case 24:                /* Opteron processor */
+
+        case 24:                /* Athlon64 & Opteron */
                 val &= 0x1f;
-                return(val == 0x1f ? 0 : 1550 - val * 25);
+                if (val == 0x1f)
+                        return 0;
+                                /* fall through */
+        case 25:                /* AMD NPT 0Fh */
+                val &= 0x3f;
+                return (val < 32) ? 1550 - 25 * val
+                        : 775 - (25 * (val - 31)) / 2;
 
         case 91:                /* VRM 9.1 */
         case 90:                /* VRM 9.0 */
@@ -141,9 +154,9 @@ int vid_from_reg(int val, u8 vrm)
 
 
 /*
-    After this point is the code to automatically determine which
-    VRM/VRD specification should be used depending on the CPU.
-*/
+ * After this point is the code to automatically determine which
+ * VRM/VRD specification should be used depending on the CPU.
+ */
 
 struct vrm_model {
         u8 vendor;
@@ -157,11 +170,17 @@ struct vrm_model {
 
 #ifdef CONFIG_X86
 
-/* the stepping parameter is highest acceptable stepping for current line */
+/*
+ * The stepping parameter is highest acceptable stepping for current line.
+ * The model match must be exact for 4-bit values. For model values 0x10
+ * and above (extended model), all models below the parameter will match.
+ */
 
 static struct vrm_model vrm_models[] = {
         {X86_VENDOR_AMD, 0x6, ANY, ANY, 90},            /* Athlon Duron etc */
-        {X86_VENDOR_AMD, 0xF, ANY, ANY, 24},            /* Athlon 64, Opteron and above VRM 24 */
+        {X86_VENDOR_AMD, 0xF, 0x3F, ANY, 24},           /* Athlon 64, Opteron */
+        {X86_VENDOR_AMD, 0xF, ANY, ANY, 25},            /* NPT family 0Fh */
+        {X86_VENDOR_AMD, 0x10, ANY, ANY, 25},           /* NPT family 10h */
         {X86_VENDOR_INTEL, 0x6, 0x9, ANY, 13},          /* Pentium M (130 nm) */
         {X86_VENDOR_INTEL, 0x6, 0xB, ANY, 85},          /* Tualatin */
         {X86_VENDOR_INTEL, 0x6, 0xD, ANY, 13},          /* Pentium M (90 nm) */
@@ -189,6 +208,8 @@ static u8 find_vrm(u8 eff_family, u8 eff_model, u8 eff_stepping, u8 vendor)
                 if (vrm_models[i].vendor==vendor)
                         if ((vrm_models[i].eff_family==eff_family)
                          && ((vrm_models[i].eff_model==eff_model) ||
+                             (vrm_models[i].eff_model >= 0x10 &&
+                              eff_model <= vrm_models[i].eff_model) ||
                              (vrm_models[i].eff_model==ANY)) &&
                              (eff_stepping <= vrm_models[i].eff_stepping))
                                 return vrm_models[i].vrm_type;
diff --git a/drivers/hwmon/hwmon.c b/drivers/hwmon/hwmon.c
index 3db28450a3b3..076a59cdabe9 100644
--- a/drivers/hwmon/hwmon.c
+++ b/drivers/hwmon/hwmon.c
@@ -55,7 +55,8 @@ again:
                 return ERR_PTR(err);
 
         id = id & MAX_ID_MASK;
-        hwdev = device_create(hwmon_class, dev, MKDEV(0,0), HWMON_ID_FORMAT, id);
+        hwdev = device_create(hwmon_class, dev, MKDEV(0, 0), NULL,
+                              HWMON_ID_FORMAT, id);
 
         if (IS_ERR(hwdev)) {
                 spin_lock(&idr_lock);
diff --git a/drivers/hwmon/i5k_amb.c b/drivers/hwmon/i5k_amb.c
index f9e2ed621f7b..2ede9388096b 100644
--- a/drivers/hwmon/i5k_amb.c
+++ b/drivers/hwmon/i5k_amb.c
@@ -81,6 +81,8 @@ static unsigned long amb_reg_temp(unsigned int amb)
 #define MAX_AMBS_PER_CHANNEL            16
 #define MAX_AMBS                        (MAX_MEM_CHANNELS * \
                                          MAX_AMBS_PER_CHANNEL)
+#define CHANNEL_SHIFT                   4
+#define DIMM_MASK                       0xF
 /*
  * Ugly hack: For some reason the highest bit is set if there
  * are _any_ DIMMs in the channel.  Attempting to read from
@@ -89,7 +91,7 @@ static unsigned long amb_reg_temp(unsigned int amb)
  * might prevent us from seeing the 16th DIMM in the channel.
  */
 #define REAL_MAX_AMBS_PER_CHANNEL       15
-#define KNOBS_PER_AMB                   5
+#define KNOBS_PER_AMB                   6
 
 static unsigned long amb_num_from_reg(unsigned int byte_num, unsigned int bit)
 {
@@ -238,6 +240,16 @@ static ssize_t show_amb_temp(struct device *dev,
                 500 * amb_read_byte(data, amb_reg_temp(attr->index)));
 }
 
+static ssize_t show_label(struct device *dev,
+                          struct device_attribute *devattr,
+                          char *buf)
+{
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+
+        return sprintf(buf, "Ch. %d DIMM %d\n", attr->index >> CHANNEL_SHIFT,
+                       attr->index & DIMM_MASK);
+}
+
 static int __devinit i5k_amb_hwmon_init(struct platform_device *pdev)
 {
         int i, j, k, d = 0;
@@ -268,6 +280,20 @@ static int __devinit i5k_amb_hwmon_init(struct platform_device *pdev)
                                 continue;
                         d++;
 
+                        /* sysfs label */
+                        iattr = data->attrs + data->num_attrs;
+                        snprintf(iattr->name, AMB_SYSFS_NAME_LEN,
+                                 "temp%d_label", d);
+                        iattr->s_attr.dev_attr.attr.name = iattr->name;
+                        iattr->s_attr.dev_attr.attr.mode = S_IRUGO;
+                        iattr->s_attr.dev_attr.show = show_label;
+                        iattr->s_attr.index = k;
+                        res = device_create_file(&pdev->dev,
+                                                 &iattr->s_attr.dev_attr);
+                        if (res)
+                                goto exit_remove;
+                        data->num_attrs++;
+
                         /* Temperature sysfs knob */
                         iattr = data->attrs + data->num_attrs;
                         snprintf(iattr->name, AMB_SYSFS_NAME_LEN,
diff --git a/drivers/hwmon/ibmaem.c b/drivers/hwmon/ibmaem.c
index c9416e657487..7b0ed5dea399 100644
--- a/drivers/hwmon/ibmaem.c
+++ b/drivers/hwmon/ibmaem.c
@@ -1,6 +1,6 @@
 /*
- * A hwmon driver for the IBM Active Energy Manager temperature/power sensors
- * and capping functionality.
+ * A hwmon driver for the IBM System Director Active Energy Manager (AEM)
+ * temperature/power/energy sensors and capping functionality.
  * Copyright (C) 2008 IBM
  *
  * Author: Darrick J. Wong <djwong@us.ibm.com>
@@ -463,12 +463,18 @@ static int aem_read_sensor(struct aem_data *data, u8 elt, u8 reg,
 }
 
 /* Update AEM energy registers */
+static void update_aem_energy_one(struct aem_data *data, int which)
+{
+        aem_read_sensor(data, AEM_ENERGY_ELEMENT, which,
+                        &data->energy[which], 8);
+}
+
 static void update_aem_energy(struct aem_data *data)
 {
-        aem_read_sensor(data, AEM_ENERGY_ELEMENT, 0, &data->energy[0], 8);
+        update_aem_energy_one(data, 0);
         if (data->ver_major < 2)
                 return;
-        aem_read_sensor(data, AEM_ENERGY_ELEMENT, 1, &data->energy[1], 8);
+        update_aem_energy_one(data, 1);
 }
 
 /* Update all AEM1 sensors */
@@ -676,7 +682,8 @@ static int aem_find_aem2(struct aem_ipmi_data *data,
                 return -ETIMEDOUT;
 
         if (data->rx_result || data->rx_msg_len != sizeof(*fi_resp) ||
-            memcmp(&fi_resp->id, &system_x_id, sizeof(system_x_id)))
+            memcmp(&fi_resp->id, &system_x_id, sizeof(system_x_id)) ||
+            fi_resp->num_instances <= instance_num)
                 return -ENOENT;
 
         return 0;
@@ -849,7 +856,7 @@ static ssize_t aem_show_power(struct device *dev,
         struct timespec b, a;
 
         mutex_lock(&data->lock);
-        update_aem_energy(data);
+        update_aem_energy_one(data, attr->index);
         getnstimeofday(&b);
         before = data->energy[attr->index];
 
@@ -861,7 +868,7 @@ static ssize_t aem_show_power(struct device *dev,
                 return 0;
         }
 
-        update_aem_energy(data);
+        update_aem_energy_one(data, attr->index);
         getnstimeofday(&a);
         after = data->energy[attr->index];
         mutex_unlock(&data->lock);
@@ -880,7 +887,9 @@ static ssize_t aem_show_energy(struct device *dev,
 {
         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
         struct aem_data *a = dev_get_drvdata(dev);
-        a->update(a);
+        mutex_lock(&a->lock);
+        update_aem_energy_one(a, attr->index);
+        mutex_unlock(&a->lock);
 
         return sprintf(buf, "%llu\n",
                         (unsigned long long)a->energy[attr->index] * 1000);
@@ -1104,8 +1113,15 @@ static void __exit aem_exit(void)
 }
 
 MODULE_AUTHOR("Darrick J. Wong <djwong@us.ibm.com>");
-MODULE_DESCRIPTION("IBM Active Energy Manager power/temp sensor driver");
+MODULE_DESCRIPTION("IBM AEM power/temp/energy sensor driver");
 MODULE_LICENSE("GPL");
 
 module_init(aem_init);
 module_exit(aem_exit);
+
+MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3350-*");
+MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3550-*");
+MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3650-*");
+MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3655-*");
+MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3755-*");
+MODULE_ALIAS("dmi:bvnIBM:*:pnIBM3850M2/x3950M2-*");
diff --git a/drivers/hwmon/ibmpex.c b/drivers/hwmon/ibmpex.c
index 4e9b19c6732f..537d9fb2ff88 100644
--- a/drivers/hwmon/ibmpex.c
+++ b/drivers/hwmon/ibmpex.c
@@ -608,3 +608,9 @@ MODULE_LICENSE("GPL");
 
 module_init(ibmpex_init);
 module_exit(ibmpex_exit);
+
+MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3350-*");
+MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3550-*");
+MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3650-*");
+MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3655-*");
+MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3755-*");
diff --git a/drivers/hwmon/it87.c b/drivers/hwmon/it87.c
index e12c132ff83a..b74c95735f95 100644
--- a/drivers/hwmon/it87.c
+++ b/drivers/hwmon/it87.c
@@ -46,6 +46,8 @@
 #include <linux/err.h>
 #include <linux/mutex.h>
 #include <linux/sysfs.h>
+#include <linux/string.h>
+#include <linux/dmi.h>
 #include <asm/io.h>
 
 #define DRVNAME "it87"
@@ -151,9 +153,9 @@ static int fix_pwm_polarity;
 /* The IT8718F has the VID value in a different register, in Super-I/O
    configuration space. */
 #define IT87_REG_VID           0x0a
-/* Warning: register 0x0b is used for something completely different in
-   new chips/revisions. I suspect only 16-bit tachometer mode will work
-   for these. */
+/* The IT8705F and IT8712F earlier than revision 0x08 use register 0x0b
+   for fan divisors. Later IT8712F revisions must use 16-bit tachometer
+   mode. */
 #define IT87_REG_FAN_DIV       0x0b
 #define IT87_REG_FAN_16BIT     0x0c
 
@@ -234,7 +236,10 @@ static const unsigned int pwm_freq[8] = {
 struct it87_sio_data {
         enum chips type;
         /* Values read from Super-I/O config space */
+        u8 revision;
         u8 vid_value;
+        /* Values set based on DMI strings */
+        u8 skip_pwm;
 };
 
 /* For each registered chip, we need to keep some data in memory.
@@ -242,6 +247,7 @@ struct it87_sio_data {
 struct it87_data {
         struct device *hwmon_dev;
         enum chips type;
+        u8 revision;
 
         unsigned short addr;
         const char *name;
@@ -268,6 +274,16 @@ struct it87_data {
         u8 manual_pwm_ctl[3];   /* manual PWM value set by user */
 };
 
+static inline int has_16bit_fans(const struct it87_data *data)
+{
+        /* IT8705F Datasheet 0.4.1, 3h == Version G.
+           IT8712F Datasheet 0.9.1, section 8.3.5 indicates 8h == Version J.
+           These are the first revisions with 16bit tachometer support. */
+        return (data->type == it87 && data->revision >= 0x03)
+            || (data->type == it8712 && data->revision >= 0x08)
+            || data->type == it8716
+            || data->type == it8718;
+}
 
 static int it87_probe(struct platform_device *pdev);
 static int __devexit it87_remove(struct platform_device *pdev);
@@ -461,7 +477,7 @@ static ssize_t show_sensor(struct device *dev, struct device_attribute *attr,
         if (reg & (1 << nr))
                 return sprintf(buf, "3\n");  /* thermal diode */
         if (reg & (8 << nr))
-                return sprintf(buf, "2\n");  /* thermistor */
+                return sprintf(buf, "4\n");  /* thermistor */
         return sprintf(buf, "0\n");      /* disabled */
 }
 static ssize_t set_sensor(struct device *dev, struct device_attribute *attr,
@@ -477,10 +493,15 @@ static ssize_t set_sensor(struct device *dev, struct device_attribute *attr,
 
         data->sensor &= ~(1 << nr);
         data->sensor &= ~(8 << nr);
-        /* 3 = thermal diode; 2 = thermistor; 0 = disabled */
+        if (val == 2) { /* backwards compatibility */
+                dev_warn(dev, "Sensor type 2 is deprecated, please use 4 "
+                         "instead\n");
+                val = 4;
+        }
+        /* 3 = thermal diode; 4 = thermistor; 0 = disabled */
         if (val == 3)
             data->sensor |= 1 << nr;
-        else if (val == 2)
+        else if (val == 4)
             data->sensor |= 8 << nr;
         else if (val != 0) {
                 mutex_unlock(&data->update_lock);
@@ -952,6 +973,7 @@ static int __init it87_find(unsigned short *address,
 {
         int err = -ENODEV;
         u16 chip_type;
+        const char *board_vendor, *board_name;
 
         superio_enter();
         chip_type = force_id ? force_id : superio_inw(DEVID);
@@ -991,8 +1013,9 @@ static int __init it87_find(unsigned short *address,
         }
 
         err = 0;
+        sio_data->revision = superio_inb(DEVREV) & 0x0f;
         pr_info("it87: Found IT%04xF chip at 0x%x, revision %d\n",
-                chip_type, *address, superio_inb(DEVREV) & 0x0f);
+                chip_type, *address, sio_data->revision);
 
         /* Read GPIO config and VID value from LDN 7 (GPIO) */
         if (chip_type != IT8705F_DEVID) {
@@ -1009,6 +1032,24 @@ static int __init it87_find(unsigned short *address,
                         pr_info("it87: in7 is VCCH (+5V Stand-By)\n");
         }
 
+        /* Disable specific features based on DMI strings */
+        board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
+        board_name = dmi_get_system_info(DMI_BOARD_NAME);
+        if (board_vendor && board_name) {
+                if (strcmp(board_vendor, "nVIDIA") == 0
+                 && strcmp(board_name, "FN68PT") == 0) {
+                        /* On the Shuttle SN68PT, FAN_CTL2 is apparently not
+                           connected to a fan, but to something else. One user
+                           has reported instant system power-off when changing
+                           the PWM2 duty cycle, so we disable it.
+                           I use the board name string as the trigger in case
+                           the same board is ever used in other systems. */
+                        pr_info("it87: Disabling pwm2 due to "
+                                "hardware constraints\n");
+                        sio_data->skip_pwm = (1 << 1);
+                }
+        }
+
 exit:
         superio_exit();
         return err;
@@ -1045,6 +1086,7 @@ static int __devinit it87_probe(struct platform_device *pdev)
 
         data->addr = res->start;
         data->type = sio_data->type;
+        data->revision = sio_data->revision;
         data->name = names[sio_data->type];
 
         /* Now, we do the remaining detection. */
@@ -1069,7 +1111,7 @@ static int __devinit it87_probe(struct platform_device *pdev)
                 goto ERROR2;
 
         /* Do not create fan files for disabled fans */
-        if (data->type == it8716 || data->type == it8718) {
+        if (has_16bit_fans(data)) {
                 /* 16-bit tachometers */
                 if (data->has_fan & (1 << 0)) {
                         if ((err = device_create_file(dev,
@@ -1154,25 +1196,33 @@ static int __devinit it87_probe(struct platform_device *pdev)
         }
 
         if (enable_pwm_interface) {
-                if ((err = device_create_file(dev,
-                     &sensor_dev_attr_pwm1_enable.dev_attr))
-                 || (err = device_create_file(dev,
-                     &sensor_dev_attr_pwm2_enable.dev_attr))
-                 || (err = device_create_file(dev,
-                     &sensor_dev_attr_pwm3_enable.dev_attr))
-                 || (err = device_create_file(dev,
-                     &sensor_dev_attr_pwm1.dev_attr))
-                 || (err = device_create_file(dev,
-                     &sensor_dev_attr_pwm2.dev_attr))
-                 || (err = device_create_file(dev,
-                     &sensor_dev_attr_pwm3.dev_attr))
-                 || (err = device_create_file(dev,
-                     &dev_attr_pwm1_freq))
-                 || (err = device_create_file(dev,
-                     &dev_attr_pwm2_freq))
-                 || (err = device_create_file(dev,
-                     &dev_attr_pwm3_freq)))
-                        goto ERROR4;
+                if (!(sio_data->skip_pwm & (1 << 0))) {
+                        if ((err = device_create_file(dev,
+                             &sensor_dev_attr_pwm1_enable.dev_attr))
+                         || (err = device_create_file(dev,
+                             &sensor_dev_attr_pwm1.dev_attr))
+                         || (err = device_create_file(dev,
+                             &dev_attr_pwm1_freq)))
+                                goto ERROR4;
+                }
+                if (!(sio_data->skip_pwm & (1 << 1))) {
+                        if ((err = device_create_file(dev,
+                             &sensor_dev_attr_pwm2_enable.dev_attr))
+                         || (err = device_create_file(dev,
+                             &sensor_dev_attr_pwm2.dev_attr))
+                         || (err = device_create_file(dev,
+                             &dev_attr_pwm2_freq)))
+                                goto ERROR4;
+                }
+                if (!(sio_data->skip_pwm & (1 << 2))) {
+                        if ((err = device_create_file(dev,
+                             &sensor_dev_attr_pwm3_enable.dev_attr))
+                         || (err = device_create_file(dev,
+                             &sensor_dev_attr_pwm3.dev_attr))
+                         || (err = device_create_file(dev,
+                             &dev_attr_pwm3_freq)))
+                                goto ERROR4;
+                }
         }
 
         if (data->type == it8712 || data->type == it8716
@@ -1350,7 +1400,7 @@ static void __devinit it87_init_device(struct platform_device *pdev)
         data->has_fan = (data->fan_main_ctrl >> 4) & 0x07;
 
         /* Set tachometers to 16-bit mode if needed */
-        if (data->type == it8716 || data->type == it8718) {
+        if (has_16bit_fans(data)) {
                 tmp = it87_read_value(data, IT87_REG_FAN_16BIT);
                 if (~tmp & 0x07 & data->has_fan) {
                         dev_dbg(&pdev->dev,
@@ -1358,10 +1408,13 @@ static void __devinit it87_init_device(struct platform_device *pdev)
                         it87_write_value(data, IT87_REG_FAN_16BIT,
                                          tmp | 0x07);
                 }
-                if (tmp & (1 << 4))
-                        data->has_fan |= (1 << 3);      /* fan4 enabled */
-                if (tmp & (1 << 5))
-                        data->has_fan |= (1 << 4);      /* fan5 enabled */
+                /* IT8705F only supports three fans. */
+                if (data->type != it87) {
+                        if (tmp & (1 << 4))
+                                data->has_fan |= (1 << 3); /* fan4 enabled */
+                        if (tmp & (1 << 5))
+                                data->has_fan |= (1 << 4); /* fan5 enabled */
+                }
         }
 
         /* Set current fan mode registers and the default settings for the
@@ -1426,7 +1479,7 @@ static struct it87_data *it87_update_device(struct device *dev)
                         data->fan[i] = it87_read_value(data,
                                        IT87_REG_FAN[i]);
                         /* Add high byte if in 16-bit mode */
-                        if (data->type == it8716 || data->type == it8718) {
+                        if (has_16bit_fans(data)) {
                                 data->fan[i] |= it87_read_value(data,
                                                 IT87_REG_FANX[i]) << 8;
                                 data->fan_min[i] |= it87_read_value(data,
@@ -1443,8 +1496,7 @@ static struct it87_data *it87_update_device(struct device *dev)
                 }
 
                 /* Newer chips don't have clock dividers */
-                if ((data->has_fan & 0x07) && data->type != it8716
-                 && data->type != it8718) {
+                if ((data->has_fan & 0x07) && !has_16bit_fans(data)) {
                         i = it87_read_value(data, IT87_REG_FAN_DIV);
                         data->fan_div[0] = i & 0x07;
                         data->fan_div[1] = (i >> 3) & 0x07;
@@ -1460,7 +1512,8 @@ static struct it87_data *it87_update_device(struct device *dev)
                 data->fan_ctl = it87_read_value(data, IT87_REG_FAN_CTL);
 
                 data->sensor = it87_read_value(data, IT87_REG_TEMP_ENABLE);
-                /* The 8705 does not have VID capability */
+                /* The 8705 does not have VID capability.
+                   The 8718 does not use IT87_REG_VID for the same purpose. */
                 if (data->type == it8712 || data->type == it8716) {
                         data->vid = it87_read_value(data, IT87_REG_VID);
                         /* The older IT8712F revisions had only 5 VID pins,
@@ -1529,6 +1582,7 @@ static int __init sm_it87_init(void)
         unsigned short isa_address=0;
         struct it87_sio_data sio_data;
 
+        memset(&sio_data, 0, sizeof(struct it87_sio_data));
         err = it87_find(&isa_address, &sio_data);
         if (err)
                 return err;
diff --git a/drivers/hwmon/lm75.c b/drivers/hwmon/lm75.c
index de698dc73020..8f9595f2fb53 100644
--- a/drivers/hwmon/lm75.c
+++ b/drivers/hwmon/lm75.c
@@ -30,14 +30,37 @@
 #include "lm75.h"
 
 
-/* Addresses to scan */
+/*
+ * This driver handles the LM75 and compatible digital temperature sensors.
+ * Only types which are _not_ listed in I2C_CLIENT_INSMOD_*() need to be
+ * listed here.  We start at 9 since I2C_CLIENT_INSMOD_*() currently allow
+ * definition of up to 8 chip types (plus zero).
+ */
+
+enum lm75_type {                /* keep sorted in alphabetical order */
+        ds1775 = 9,
+        ds75,
+        /* lm75 -- in I2C_CLIENT_INSMOD_1() */
+        lm75a,
+        max6625,
+        max6626,
+        mcp980x,
+        stds75,
+        tcn75,
+        tmp100,
+        tmp101,
+        tmp175,
+        tmp275,
+        tmp75,
+};
+
+/* Addresses scanned */
 static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b, 0x4c,
                                         0x4d, 0x4e, 0x4f, I2C_CLIENT_END };
 
 /* Insmod parameters */
 I2C_CLIENT_INSMOD_1(lm75);
 
-/* Many LM75 constants specified below */
 
 /* The LM75 registers */
 #define LM75_REG_CONF           0x01
@@ -49,10 +72,10 @@ static const u8 LM75_REG_TEMP[3] = {
 
 /* Each client has this additional data */
 struct lm75_data {
-        struct i2c_client       client;
-        struct device *hwmon_dev;
+        struct device           *hwmon_dev;
         struct mutex            update_lock;
-        char                    valid;          /* !=0 if following fields are valid */
+        u8                      orig_conf;
+        char                    valid;          /* !=0 if registers are valid */
         unsigned long           last_updated;   /* In jiffies */
         u16                     temp[3];        /* Register values,
                                                    0 = input
@@ -60,23 +83,14 @@ struct lm75_data {
                                                    2 = hyst */
 };
 
-static int lm75_attach_adapter(struct i2c_adapter *adapter);
-static int lm75_detect(struct i2c_adapter *adapter, int address, int kind);
-static void lm75_init_client(struct i2c_client *client);
-static int lm75_detach_client(struct i2c_client *client);
 static int lm75_read_value(struct i2c_client *client, u8 reg);
 static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value);
 static struct lm75_data *lm75_update_device(struct device *dev);
 
 
-/* This is the driver that will be inserted */
-static struct i2c_driver lm75_driver = {
-        .driver = {
-                .name   = "lm75",
-        },
-        .attach_adapter = lm75_attach_adapter,
-        .detach_client  = lm75_detach_client,
-};
+/*-----------------------------------------------------------------------*/
+
+/* sysfs attributes for hwmon */
 
 static ssize_t show_temp(struct device *dev, struct device_attribute *da,
                          char *buf)
@@ -109,13 +123,6 @@ static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO,
                         show_temp, set_temp, 2);
 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
 
-static int lm75_attach_adapter(struct i2c_adapter *adapter)
-{
-        if (!(adapter->class & I2C_CLASS_HWMON))
-                return 0;
-        return i2c_probe(adapter, &addr_data, lm75_detect);
-}
-
 static struct attribute *lm75_attributes[] = {
         &sensor_dev_attr_temp1_input.dev_attr.attr,
         &sensor_dev_attr_temp1_max.dev_attr.attr,
@@ -128,33 +135,114 @@ static const struct attribute_group lm75_group = {
         .attrs = lm75_attributes,
 };
 
-/* This function is called by i2c_probe */
-static int lm75_detect(struct i2c_adapter *adapter, int address, int kind)
+/*-----------------------------------------------------------------------*/
+
+/* device probe and removal */
+
+static int
+lm75_probe(struct i2c_client *client, const struct i2c_device_id *id)
 {
-        int i;
-        struct i2c_client *new_client;
         struct lm75_data *data;
-        int err = 0;
-        const char *name = "";
+        int status;
+        u8 set_mask, clr_mask;
+        int new;
 
-        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
-                                     I2C_FUNC_SMBUS_WORD_DATA))
-                goto exit;
-
-        /* OK. For now, 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 access lm75_{read,write}_value. */
-        if (!(data = kzalloc(sizeof(struct lm75_data), GFP_KERNEL))) {
-                err = -ENOMEM;
-                goto exit;
+        if (!i2c_check_functionality(client->adapter,
+                        I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA))
+                return -EIO;
+
+        data = kzalloc(sizeof(struct lm75_data), GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+
+        i2c_set_clientdata(client, data);
+        mutex_init(&data->update_lock);
+
+        /* Set to LM75 resolution (9 bits, 1/2 degree C) and range.
+         * Then tweak to be more precise when appropriate.
+         */
+        set_mask = 0;
+        clr_mask = (1 << 0)                     /* continuous conversions */
+                | (1 << 6) | (1 << 5);          /* 9-bit mode */
+
+        /* configure as specified */
+        status = lm75_read_value(client, LM75_REG_CONF);
+        if (status < 0) {
+                dev_dbg(&client->dev, "Can't read config? %d\n", status);
+                goto exit_free;
         }
+        data->orig_conf = status;
+        new = status & ~clr_mask;
+        new |= set_mask;
+        if (status != new)
+                lm75_write_value(client, LM75_REG_CONF, new);
+        dev_dbg(&client->dev, "Config %02x\n", new);
+
+        /* Register sysfs hooks */
+        status = sysfs_create_group(&client->dev.kobj, &lm75_group);
+        if (status)
+                goto exit_free;
+
+        data->hwmon_dev = hwmon_device_register(&client->dev);
+        if (IS_ERR(data->hwmon_dev)) {
+                status = PTR_ERR(data->hwmon_dev);
+                goto exit_remove;
+        }
+
+        dev_info(&client->dev, "%s: sensor '%s'\n",
+                data->hwmon_dev->bus_id, client->name);
+
+        return 0;
+
+exit_remove:
+        sysfs_remove_group(&client->dev.kobj, &lm75_group);
+exit_free:
+        i2c_set_clientdata(client, NULL);
+        kfree(data);
+        return status;
+}
+
+static int lm75_remove(struct i2c_client *client)
+{
+        struct lm75_data *data = i2c_get_clientdata(client);
+
+        hwmon_device_unregister(data->hwmon_dev);
+        sysfs_remove_group(&client->dev.kobj, &lm75_group);
+        lm75_write_value(client, LM75_REG_CONF, data->orig_conf);
+        i2c_set_clientdata(client, NULL);
+        kfree(data);
+        return 0;
+}
+
+static const struct i2c_device_id lm75_ids[] = {
+        { "ds1775", ds1775, },
+        { "ds75", ds75, },
+        { "lm75", lm75, },
+        { "lm75a", lm75a, },
+        { "max6625", max6625, },
+        { "max6626", max6626, },
+        { "mcp980x", mcp980x, },
+        { "stds75", stds75, },
+        { "tcn75", tcn75, },
+        { "tmp100", tmp100, },
+        { "tmp101", tmp101, },
+        { "tmp175", tmp175, },
+        { "tmp275", tmp275, },
+        { "tmp75", tmp75, },
+        { /* LIST END */ }
+};
+MODULE_DEVICE_TABLE(i2c, lm75_ids);
+
+/* Return 0 if detection is successful, -ENODEV otherwise */
+static int lm75_detect(struct i2c_client *new_client, int kind,
+                       struct i2c_board_info *info)
+{
+        struct i2c_adapter *adapter = new_client->adapter;
+        int i;
 
-        new_client = &data->client;
-        i2c_set_clientdata(new_client, data);
-        new_client->addr = address;
-        new_client->adapter = adapter;
-        new_client->driver = &lm75_driver;
-        new_client->flags = 0;
+        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
+                                     I2C_FUNC_SMBUS_WORD_DATA))
+                return -ENODEV;
 
         /* Now, we do the remaining detection. There is no identification-
            dedicated register so we have to rely on several tricks:
@@ -174,77 +262,49 @@ static int lm75_detect(struct i2c_adapter *adapter, int address, int kind)
                  || i2c_smbus_read_word_data(new_client, 5) != hyst
                  || i2c_smbus_read_word_data(new_client, 6) != hyst
                  || i2c_smbus_read_word_data(new_client, 7) != hyst)
-                        goto exit_free;
+                        return -ENODEV;
                 os = i2c_smbus_read_word_data(new_client, 3);
                 if (i2c_smbus_read_word_data(new_client, 4) != os
                  || i2c_smbus_read_word_data(new_client, 5) != os
                  || i2c_smbus_read_word_data(new_client, 6) != os
                  || i2c_smbus_read_word_data(new_client, 7) != os)
-                        goto exit_free;
+                        return -ENODEV;
 
                 /* Unused bits */
                 if (conf & 0xe0)
-                        goto exit_free;
+                        return -ENODEV;
 
                 /* Addresses cycling */
                 for (i = 8; i < 0xff; i += 8)
                         if (i2c_smbus_read_byte_data(new_client, i + 1) != conf
                          || i2c_smbus_read_word_data(new_client, i + 2) != hyst
                          || i2c_smbus_read_word_data(new_client, i + 3) != os)
-                                goto exit_free;
+                                return -ENODEV;
         }
 
-        /* Determine the chip type - only one kind supported! */
-        if (kind <= 0)
-                kind = lm75;
-
-        if (kind == lm75) {
-                name = "lm75";
-        }
-
-        /* Fill in the remaining client fields and put it into the global list */
-        strlcpy(new_client->name, name, I2C_NAME_SIZE);
-        data->valid = 0;
-        mutex_init(&data->update_lock);
-
-        /* Tell the I2C layer a new client has arrived */
-        if ((err = i2c_attach_client(new_client)))
-                goto exit_free;
-
-        /* Initialize the LM75 chip */
-        lm75_init_client(new_client);
-        
-        /* Register sysfs hooks */
-        if ((err = sysfs_create_group(&new_client->dev.kobj, &lm75_group)))
-                goto exit_detach;
-
-        data->hwmon_dev = hwmon_device_register(&new_client->dev);
-        if (IS_ERR(data->hwmon_dev)) {
-                err = PTR_ERR(data->hwmon_dev);
-                goto exit_remove;
-        }
+        /* NOTE: we treat "force=..." and "force_lm75=..." the same.
+         * Only new-style driver binding distinguishes chip types.
+         */
+        strlcpy(info->type, "lm75", I2C_NAME_SIZE);
 
         return 0;
-
-exit_remove:
-        sysfs_remove_group(&new_client->dev.kobj, &lm75_group);
-exit_detach:
-        i2c_detach_client(new_client);
-exit_free:
-        kfree(data);
-exit:
-        return err;
 }
 
-static int lm75_detach_client(struct i2c_client *client)
-{
-        struct lm75_data *data = i2c_get_clientdata(client);
-        hwmon_device_unregister(data->hwmon_dev);
-        sysfs_remove_group(&client->dev.kobj, &lm75_group);
-        i2c_detach_client(client);
-        kfree(data);
-        return 0;
-}
+static struct i2c_driver lm75_driver = {
+        .class          = I2C_CLASS_HWMON,
+        .driver = {
+                .name   = "lm75",
+        },
+        .probe          = lm75_probe,
+        .remove         = lm75_remove,
+        .id_table       = lm75_ids,
+        .detect         = lm75_detect,
+        .address_data   = &addr_data,
+};
+
+/*-----------------------------------------------------------------------*/
+
+/* register access */
 
 /* All registers are word-sized, except for the configuration register.
    LM75 uses a high-byte first convention, which is exactly opposite to
@@ -268,16 +328,6 @@ static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value)
                 return i2c_smbus_write_word_data(client, reg, swab16(value));
 }
 
-static void lm75_init_client(struct i2c_client *client)
-{
-        int reg;
-
-        /* Enable if in shutdown mode */
-        reg = lm75_read_value(client, LM75_REG_CONF);
-        if (reg >= 0 && (reg & 0x01))
-                lm75_write_value(client, LM75_REG_CONF, reg & 0xfe);
-}
-
 static struct lm75_data *lm75_update_device(struct device *dev)
 {
         struct i2c_client *client = to_i2c_client(dev);
@@ -309,6 +359,10 @@ static struct lm75_data *lm75_update_device(struct device *dev)
         return data;
 }
 
+/*-----------------------------------------------------------------------*/
+
+/* module glue */
+
 static int __init sensors_lm75_init(void)
 {
         return i2c_add_driver(&lm75_driver);
diff --git a/drivers/hwmon/lm78.c b/drivers/hwmon/lm78.c
index ed7859f0e16a..b5e3b2851698 100644
--- a/drivers/hwmon/lm78.c
+++ b/drivers/hwmon/lm78.c
@@ -114,25 +114,16 @@ static inline int TEMP_FROM_REG(s8 val)
 
 #define DIV_FROM_REG(val) (1 << (val))
 
-/* There are some complications in a module like this. First off, LM78 chips
-   may be both present on the SMBus and the ISA bus, and we have to handle
-   those cases separately at some places. Second, there might be several
-   LM78 chips available (well, actually, that is probably never done; but
-   it is a clean illustration of how to handle a case like that). Finally,
-   a specific chip may be attached to *both* ISA and SMBus, and we would
-   not like to detect it double. Fortunately, in the case of the LM78 at
-   least, a register tells us what SMBus address we are on, so that helps
-   a bit - except if there could be more than one SMBus. Groan. No solution
-   for this yet. */
-
-/* For ISA chips, we abuse the i2c_client addr and name fields. We also use
-   the driver field to differentiate between I2C and ISA chips. */
 struct lm78_data {
-        struct i2c_client client;
+        struct i2c_client *client;
         struct device *hwmon_dev;
         struct mutex lock;
         enum chips type;
 
+        /* For ISA device only */
+        const char *name;
+        int isa_addr;
+
         struct mutex update_lock;
         char valid;             /* !=0 if following fields are valid */
         unsigned long last_updated;     /* In jiffies */
@@ -151,9 +142,11 @@ struct lm78_data {
 };
 
 
-static int lm78_attach_adapter(struct i2c_adapter *adapter);
-static int lm78_detect(struct i2c_adapter *adapter, int address, int kind);
-static int lm78_detach_client(struct i2c_client *client);
+static int lm78_i2c_detect(struct i2c_client *client, int kind,
+                           struct i2c_board_info *info);
+static int lm78_i2c_probe(struct i2c_client *client,
+                          const struct i2c_device_id *id);
+static int lm78_i2c_remove(struct i2c_client *client);
 
 static int __devinit lm78_isa_probe(struct platform_device *pdev);
 static int __devexit lm78_isa_remove(struct platform_device *pdev);
@@ -164,12 +157,23 @@ static struct lm78_data *lm78_update_device(struct device *dev);
 static void lm78_init_device(struct lm78_data *data);
 
 
+static const struct i2c_device_id lm78_i2c_id[] = {
+        { "lm78", lm78 },
+        { "lm79", lm79 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, lm78_i2c_id);
+
 static struct i2c_driver lm78_driver = {
+        .class          = I2C_CLASS_HWMON,
         .driver = {
                 .name   = "lm78",
         },
-        .attach_adapter = lm78_attach_adapter,
-        .detach_client  = lm78_detach_client,
+        .probe          = lm78_i2c_probe,
+        .remove         = lm78_i2c_remove,
+        .id_table       = lm78_i2c_id,
+        .detect         = lm78_i2c_detect,
+        .address_data   = &addr_data,
 };
 
 static struct platform_driver lm78_isa_driver = {
@@ -454,17 +458,6 @@ static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7);
 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11);
 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4);
 
-/* This function is called when:
-     * lm78_driver is inserted (when this module is loaded), for each
-       available adapter
-     * when a new adapter is inserted (and lm78_driver is still present) */
-static int lm78_attach_adapter(struct i2c_adapter *adapter)
-{
-        if (!(adapter->class & I2C_CLASS_HWMON))
-                return 0;
-        return i2c_probe(adapter, &addr_data, lm78_detect);
-}
-
 static struct attribute *lm78_attributes[] = {
         &sensor_dev_attr_in0_input.dev_attr.attr,
         &sensor_dev_attr_in0_min.dev_attr.attr,
@@ -527,54 +520,77 @@ static ssize_t show_name(struct device *dev, struct device_attribute
 {
         struct lm78_data *data = dev_get_drvdata(dev);
 
-        return sprintf(buf, "%s\n", data->client.name);
+        return sprintf(buf, "%s\n", data->name);
 }
 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
 
-/* This function is called by i2c_probe */
-static int lm78_detect(struct i2c_adapter *adapter, int address, int kind)
+/* Returns 1 if the I2C chip appears to be an alias of the ISA chip */
+static int lm78_alias_detect(struct i2c_client *client, u8 chipid)
 {
-        int i, err;
-        struct i2c_client *new_client;
-        struct lm78_data *data;
-        const char *client_name = "";
+        struct lm78_data *isa;
+        int i;
 
-        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
-                err = -ENODEV;
-                goto ERROR1;
+        if (!pdev)      /* No ISA chip */
+                return 0;
+        isa = platform_get_drvdata(pdev);
+
+        if (lm78_read_value(isa, LM78_REG_I2C_ADDR) != client->addr)
+                return 0;       /* Address doesn't match */
+        if ((lm78_read_value(isa, LM78_REG_CHIPID) & 0xfe) != (chipid & 0xfe))
+                return 0;       /* Chip type doesn't match */
+
+        /* We compare all the limit registers, the config register and the
+         * interrupt mask registers */
+        for (i = 0x2b; i <= 0x3d; i++) {
+                if (lm78_read_value(isa, i) !=
+                    i2c_smbus_read_byte_data(client, i))
+                        return 0;
         }
+        if (lm78_read_value(isa, LM78_REG_CONFIG) !=
+            i2c_smbus_read_byte_data(client, LM78_REG_CONFIG))
+                return 0;
+        for (i = 0x43; i <= 0x46; i++) {
+                if (lm78_read_value(isa, i) !=
+                    i2c_smbus_read_byte_data(client, i))
+                        return 0;
+        }
+
+        return 1;
+}
 
-        /* OK. For now, 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 access lm78_{read,write}_value. */
+static int lm78_i2c_detect(struct i2c_client *client, int kind,
+                           struct i2c_board_info *info)
+{
+        int i;
+        struct lm78_data *isa = pdev ? platform_get_drvdata(pdev) : NULL;
+        const char *client_name;
+        struct i2c_adapter *adapter = client->adapter;
+        int address = client->addr;
 
-        if (!(data = kzalloc(sizeof(struct lm78_data), GFP_KERNEL))) {
-                err = -ENOMEM;
-                goto ERROR1;
-        }
+        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
+                return -ENODEV;
 
-        new_client = &data->client;
-        i2c_set_clientdata(new_client, data);
-        new_client->addr = address;
-        new_client->adapter = adapter;
-        new_client->driver = &lm78_driver;
+        /* We block updates of the ISA device to minimize the risk of
+           concurrent access to the same LM78 chip through different
+           interfaces. */
+        if (isa)
+                mutex_lock(&isa->update_lock);
 
-        /* Now, we do the remaining detection. */
         if (kind < 0) {
-                if (lm78_read_value(data, LM78_REG_CONFIG) & 0x80) {
-                        err = -ENODEV;
-                        goto ERROR2;
-                }
-                if (lm78_read_value(data, LM78_REG_I2C_ADDR) !=
-                    address) {
-                        err = -ENODEV;
-                        goto ERROR2;
-                }
+                if ((i2c_smbus_read_byte_data(client, LM78_REG_CONFIG) & 0x80)
+                 || i2c_smbus_read_byte_data(client, LM78_REG_I2C_ADDR)
+                    != address)
+                        goto err_nodev;
+
+                /* Explicitly prevent the misdetection of Winbond chips */
+                i = i2c_smbus_read_byte_data(client, 0x4f);
+                if (i == 0xa3 || i == 0x5c)
+                        goto err_nodev;
         }
 
         /* Determine the chip type. */
         if (kind <= 0) {
-                i = lm78_read_value(data, LM78_REG_CHIPID);
+                i = i2c_smbus_read_byte_data(client, LM78_REG_CHIPID);
                 if (i == 0x00 || i == 0x20      /* LM78 */
                  || i == 0x40)                  /* LM78-J */
                         kind = lm78;
@@ -586,33 +602,59 @@ static int lm78_detect(struct i2c_adapter *adapter, int address, int kind)
                                         "parameter for unknown chip at "
                                         "adapter %d, address 0x%02x\n",
                                         i2c_adapter_id(adapter), address);
-                        err = -ENODEV;
-                        goto ERROR2;
+                        goto err_nodev;
+                }
+
+                if (lm78_alias_detect(client, i)) {
+                        dev_dbg(&adapter->dev, "Device at 0x%02x appears to "
+                                "be the same as ISA device\n", address);
+                        goto err_nodev;
                 }
         }
 
-        if (kind == lm78) {
-                client_name = "lm78";
-        } else if (kind == lm79) {
+        if (isa)
+                mutex_unlock(&isa->update_lock);
+
+        switch (kind) {
+        case lm79:
                 client_name = "lm79";
+                break;
+        default:
+                client_name = "lm78";
         }
+        strlcpy(info->type, client_name, I2C_NAME_SIZE);
+
+        return 0;
+
+ err_nodev:
+        if (isa)
+                mutex_unlock(&isa->update_lock);
+        return -ENODEV;
+}
+
+static int lm78_i2c_probe(struct i2c_client *client,
+                          const struct i2c_device_id *id)
+{
+        struct lm78_data *data;
+        int err;
 
-        /* Fill in the remaining client fields and put into the global list */
-        strlcpy(new_client->name, client_name, I2C_NAME_SIZE);
-        data->type = kind;
+        data = kzalloc(sizeof(struct lm78_data), GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
 
-        /* Tell the I2C layer a new client has arrived */
-        if ((err = i2c_attach_client(new_client)))
-                goto ERROR2;
+        i2c_set_clientdata(client, data);
+        data->client = client;
+        data->type = id->driver_data;
 
         /* Initialize the LM78 chip */
         lm78_init_device(data);
 
         /* Register sysfs hooks */
-        if ((err = sysfs_create_group(&new_client->dev.kobj, &lm78_group)))
+        err = sysfs_create_group(&client->dev.kobj, &lm78_group);
+        if (err)
                 goto ERROR3;
 
-        data->hwmon_dev = hwmon_device_register(&new_client->dev);
+        data->hwmon_dev = hwmon_device_register(&client->dev);
         if (IS_ERR(data->hwmon_dev)) {
                 err = PTR_ERR(data->hwmon_dev);
                 goto ERROR4;
@@ -621,26 +663,18 @@ static int lm78_detect(struct i2c_adapter *adapter, int address, int kind)
         return 0;
 
 ERROR4:
-        sysfs_remove_group(&new_client->dev.kobj, &lm78_group);
+        sysfs_remove_group(&client->dev.kobj, &lm78_group);
 ERROR3:
-        i2c_detach_client(new_client);
-ERROR2:
         kfree(data);
-ERROR1:
         return err;
 }
 
-static int lm78_detach_client(struct i2c_client *client)
+static int lm78_i2c_remove(struct i2c_client *client)
 {
         struct lm78_data *data = i2c_get_clientdata(client);
-        int err;
 
         hwmon_device_unregister(data->hwmon_dev);
         sysfs_remove_group(&client->dev.kobj, &lm78_group);
-
-        if ((err = i2c_detach_client(client)))
-                return err;
-
         kfree(data);
 
         return 0;
@@ -651,11 +685,10 @@ static int __devinit lm78_isa_probe(struct platform_device *pdev)
         int err;
         struct lm78_data *data;
         struct resource *res;
-        const char *name;
 
         /* Reserve the ISA region */
         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
-        if (!request_region(res->start, LM78_EXTENT, "lm78")) {
+        if (!request_region(res->start + LM78_ADDR_REG_OFFSET, 2, "lm78")) {
                 err = -EBUSY;
                 goto exit;
         }
@@ -665,18 +698,16 @@ static int __devinit lm78_isa_probe(struct platform_device *pdev)
                 goto exit_release_region;
         }
         mutex_init(&data->lock);
-        data->client.addr = res->start;
-        i2c_set_clientdata(&data->client, data);
+        data->isa_addr = res->start;
         platform_set_drvdata(pdev, data);
 
         if (lm78_read_value(data, LM78_REG_CHIPID) & 0x80) {
                 data->type = lm79;
-                name = "lm79";
+                data->name = "lm79";
         } else {
                 data->type = lm78;
-                name = "lm78";
+                data->name = "lm78";
         }
-        strlcpy(data->client.name, name, I2C_NAME_SIZE);
 
         /* Initialize the LM78 chip */
         lm78_init_device(data);
@@ -699,7 +730,7 @@ static int __devinit lm78_isa_probe(struct platform_device *pdev)
         device_remove_file(&pdev->dev, &dev_attr_name);
         kfree(data);
  exit_release_region:
-        release_region(res->start, LM78_EXTENT);
+        release_region(res->start + LM78_ADDR_REG_OFFSET, 2);
  exit:
         return err;
 }
@@ -707,13 +738,16 @@ static int __devinit lm78_isa_probe(struct platform_device *pdev)
 static int __devexit lm78_isa_remove(struct platform_device *pdev)
 {
         struct lm78_data *data = platform_get_drvdata(pdev);
+        struct resource *res;
 
         hwmon_device_unregister(data->hwmon_dev);
         sysfs_remove_group(&pdev->dev.kobj, &lm78_group);
         device_remove_file(&pdev->dev, &dev_attr_name);
-        release_region(data->client.addr, LM78_EXTENT);
         kfree(data);
 
+        res = platform_get_resource(pdev, IORESOURCE_IO, 0);
+        release_region(res->start + LM78_ADDR_REG_OFFSET, 2);
+
         return 0;
 }
 
@@ -724,13 +758,13 @@ static int __devexit lm78_isa_remove(struct platform_device *pdev)
    would slow down the LM78 access and should not be necessary.  */
 static int lm78_read_value(struct lm78_data *data, u8 reg)
 {
-        struct i2c_client *client = &data->client;
+        struct i2c_client *client = data->client;
 
-        if (!client->driver) { /* ISA device */
+        if (!client) { /* ISA device */
                 int res;
                 mutex_lock(&data->lock);
-                outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET);
-                res = inb_p(client->addr + LM78_DATA_REG_OFFSET);
+                outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET);
+                res = inb_p(data->isa_addr + LM78_DATA_REG_OFFSET);
                 mutex_unlock(&data->lock);
                 return res;
         } else
@@ -746,12 +780,12 @@ static int lm78_read_value(struct lm78_data *data, u8 reg)
    nowhere else be necessary! */
 static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value)
 {
-        struct i2c_client *client = &data->client;
+        struct i2c_client *client = data->client;
 
-        if (!client->driver) { /* ISA device */
+        if (!client) { /* ISA device */
                 mutex_lock(&data->lock);
-                outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET);
-                outb_p(value, client->addr + LM78_DATA_REG_OFFSET);
+                outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET);
+                outb_p(value, data->isa_addr + LM78_DATA_REG_OFFSET);
                 mutex_unlock(&data->lock);
                 return 0;
         } else
@@ -837,8 +871,17 @@ static int __init lm78_isa_found(unsigned short address)
 {
         int val, save, found = 0;
 
-        if (!request_region(address, LM78_EXTENT, "lm78"))
+        /* We have to request the region in two parts because some
+           boards declare base+4 to base+7 as a PNP device */
+        if (!request_region(address, 4, "lm78")) {
+                pr_debug("lm78: Failed to request low part of region\n");
                 return 0;
+        }
+        if (!request_region(address + 4, 4, "lm78")) {
+                pr_debug("lm78: Failed to request high part of region\n");
+                release_region(address, 4);
+                return 0;
+        }
 
 #define REALLY_SLOW_IO
         /* We need the timeouts for at least some LM78-like
@@ -901,7 +944,8 @@ static int __init lm78_isa_found(unsigned short address)
                         val & 0x80 ? "LM79" : "LM78", (int)address);
 
  release:
-        release_region(address, LM78_EXTENT);
+        release_region(address + 4, 4);
+        release_region(address, 4);
         return found;
 }
 
@@ -949,14 +993,12 @@ static int __init sm_lm78_init(void)
 {
         int res;
 
-        res = i2c_add_driver(&lm78_driver);
-        if (res)
-                goto exit;
-
+        /* We register the ISA device first, so that we can skip the
+         * registration of an I2C interface to the same device. */
         if (lm78_isa_found(isa_address)) {
                 res = platform_driver_register(&lm78_isa_driver);
                 if (res)
-                        goto exit_unreg_i2c_driver;
+                        goto exit;
 
                 /* Sets global pdev as a side effect */
                 res = lm78_isa_device_add(isa_address);
@@ -964,12 +1006,16 @@ static int __init sm_lm78_init(void)
                         goto exit_unreg_isa_driver;
         }
 
+        res = i2c_add_driver(&lm78_driver);
+        if (res)
+                goto exit_unreg_isa_device;
+
         return 0;
 
+ exit_unreg_isa_device:
+        platform_device_unregister(pdev);
  exit_unreg_isa_driver:
         platform_driver_unregister(&lm78_isa_driver);
- exit_unreg_i2c_driver:
-        i2c_del_driver(&lm78_driver);
  exit:
         return res;
 }
diff --git a/drivers/hwmon/lm85.c b/drivers/hwmon/lm85.c
index ee5eca1c1921..3ff0285396fa 100644
--- a/drivers/hwmon/lm85.c
+++ b/drivers/hwmon/lm85.c
@@ -1,10 +1,11 @@
 /*
     lm85.c - Part of lm_sensors, Linux kernel modules for hardware
              monitoring
-    Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl> 
+    Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl>
     Copyright (c) 2002, 2003  Philip Pokorny <ppokorny@penguincomputing.com>
     Copyright (c) 2003        Margit Schubert-While <margitsw@t-online.de>
     Copyright (c) 2004        Justin Thiessen <jthiessen@penguincomputing.com>
+    Copyright (C) 2007, 2008  Jean Delvare <khali@linux-fr.org>
 
     Chip details at           <http://www.national.com/ds/LM/LM85.pdf>
 
@@ -51,24 +52,17 @@ I2C_CLIENT_INSMOD_6(lm85b, lm85c, adm1027, adt7463, emc6d100, emc6d102);
 #define LM85_REG_TEMP_MAX(nr)           (0x4f + (nr) * 2)
 
 /* Fan speeds are LSB, MSB (2 bytes) */
-#define LM85_REG_FAN(nr)                (0x28 + (nr) *2)
-#define LM85_REG_FAN_MIN(nr)            (0x54 + (nr) *2)
+#define LM85_REG_FAN(nr)                (0x28 + (nr) * 2)
+#define LM85_REG_FAN_MIN(nr)            (0x54 + (nr) * 2)
 
 #define LM85_REG_PWM(nr)                (0x30 + (nr))
 
-#define ADT7463_REG_OPPOINT(nr)         (0x33 + (nr))
-
-#define ADT7463_REG_TMIN_CTL1           0x36
-#define ADT7463_REG_TMIN_CTL2           0x37
-
-#define LM85_REG_DEVICE                 0x3d
 #define LM85_REG_COMPANY                0x3e
 #define LM85_REG_VERSTEP                0x3f
 /* These are the recognized values for the above regs */
-#define LM85_DEVICE_ADX                 0x27
 #define LM85_COMPANY_NATIONAL           0x01
 #define LM85_COMPANY_ANALOG_DEV         0x41
-#define LM85_COMPANY_SMSC               0x5c
+#define LM85_COMPANY_SMSC               0x5c
 #define LM85_VERSTEP_VMASK              0xf0
 #define LM85_VERSTEP_GENERIC            0x60
 #define LM85_VERSTEP_LM85C              0x60
@@ -91,58 +85,45 @@ I2C_CLIENT_INSMOD_6(lm85b, lm85c, adm1027, adt7463, emc6d100, emc6d102);
 #define LM85_REG_AFAN_CONFIG(nr)        (0x5c + (nr))
 #define LM85_REG_AFAN_RANGE(nr)         (0x5f + (nr))
 #define LM85_REG_AFAN_SPIKE1            0x62
-#define LM85_REG_AFAN_SPIKE2            0x63
 #define LM85_REG_AFAN_MINPWM(nr)        (0x64 + (nr))
 #define LM85_REG_AFAN_LIMIT(nr)         (0x67 + (nr))
 #define LM85_REG_AFAN_CRITICAL(nr)      (0x6a + (nr))
 #define LM85_REG_AFAN_HYST1             0x6d
 #define LM85_REG_AFAN_HYST2             0x6e
 
-#define LM85_REG_TACH_MODE              0x74
-#define LM85_REG_SPINUP_CTL             0x75
-
-#define ADM1027_REG_TEMP_OFFSET(nr)     (0x70 + (nr))
-#define ADM1027_REG_CONFIG2             0x73
-#define ADM1027_REG_INTMASK1            0x74
-#define ADM1027_REG_INTMASK2            0x75
 #define ADM1027_REG_EXTEND_ADC1         0x76
 #define ADM1027_REG_EXTEND_ADC2         0x77
-#define ADM1027_REG_CONFIG3             0x78
-#define ADM1027_REG_FAN_PPR             0x7b
-
-#define ADT7463_REG_THERM               0x79
-#define ADT7463_REG_THERM_LIMIT         0x7A
 
 #define EMC6D100_REG_ALARM3             0x7d
 /* IN5, IN6 and IN7 */
-#define EMC6D100_REG_IN(nr)             (0x70 + ((nr)-5))
-#define EMC6D100_REG_IN_MIN(nr)         (0x73 + ((nr)-5) * 2)
-#define EMC6D100_REG_IN_MAX(nr)         (0x74 + ((nr)-5) * 2)
+#define EMC6D100_REG_IN(nr)             (0x70 + ((nr) - 5))
+#define EMC6D100_REG_IN_MIN(nr)         (0x73 + ((nr) - 5) * 2)
+#define EMC6D100_REG_IN_MAX(nr)         (0x74 + ((nr) - 5) * 2)
 #define EMC6D102_REG_EXTEND_ADC1        0x85
 #define EMC6D102_REG_EXTEND_ADC2        0x86
 #define EMC6D102_REG_EXTEND_ADC3        0x87
 #define EMC6D102_REG_EXTEND_ADC4        0x88
 
 
-/* Conversions. Rounding and limit checking is only done on the TO_REG 
+/* Conversions. Rounding and limit checking is only done on the TO_REG
    variants. Note that you should be a bit careful with which arguments
    these macros are called: arguments may be evaluated more than once.
  */
 
 /* IN are scaled acording to built-in resistors */
-static int lm85_scaling[] = {  /* .001 Volts */
-                2500, 2250, 3300, 5000, 12000,
-                3300, 1500, 1800 /*EMC6D100*/
-        };
-#define SCALE(val,from,to)              (((val)*(to) + ((from)/2))/(from))
+static const int lm85_scaling[] = {  /* .001 Volts */
+        2500, 2250, 3300, 5000, 12000,
+        3300, 1500, 1800 /*EMC6D100*/
+};
+#define SCALE(val, from, to)    (((val) * (to) + ((from) / 2)) / (from))
 
-#define INS_TO_REG(n,val)       \
-                SENSORS_LIMIT(SCALE(val,lm85_scaling[n],192),0,255)
+#define INS_TO_REG(n, val)      \
+                SENSORS_LIMIT(SCALE(val, lm85_scaling[n], 192), 0, 255)
 
-#define INSEXT_FROM_REG(n,val,ext)      \
+#define INSEXT_FROM_REG(n, val, ext)    \
                 SCALE(((val) << 4) + (ext), 192 << 4, lm85_scaling[n])
 
-#define INS_FROM_REG(n,val)     SCALE((val), 192, lm85_scaling[n])
+#define INS_FROM_REG(n, val)    SCALE((val), 192, lm85_scaling[n])
 
 /* FAN speed is measured using 90kHz clock */
 static inline u16 FAN_TO_REG(unsigned long val)
@@ -151,16 +132,17 @@ static inline u16 FAN_TO_REG(unsigned long val)
                 return 0xffff;
         return SENSORS_LIMIT(5400000 / val, 1, 0xfffe);
 }
-#define FAN_FROM_REG(val)       ((val)==0?-1:(val)==0xffff?0:5400000/(val))
+#define FAN_FROM_REG(val)       ((val) == 0 ? -1 : (val) == 0xffff ? 0 : \
+                                 5400000 / (val))
 
 /* Temperature is reported in .001 degC increments */
 #define TEMP_TO_REG(val)        \
-                SENSORS_LIMIT(SCALE(val,1000,1),-127,127)
-#define TEMPEXT_FROM_REG(val,ext)       \
+                SENSORS_LIMIT(SCALE(val, 1000, 1), -127, 127)
+#define TEMPEXT_FROM_REG(val, ext)      \
                 SCALE(((val) << 4) + (ext), 16, 1000)
 #define TEMP_FROM_REG(val)      ((val) * 1000)
 
-#define PWM_TO_REG(val)                 (SENSORS_LIMIT(val,0,255))
+#define PWM_TO_REG(val)                 SENSORS_LIMIT(val, 0, 255)
 #define PWM_FROM_REG(val)               (val)
 
 
@@ -183,52 +165,48 @@ static inline u16 FAN_TO_REG(unsigned long val)
  */
 
 /* These are the zone temperature range encodings in .001 degree C */
-static int lm85_range_map[] = {   
-                2000,  2500,  3300,  4000,  5000,  6600,
-                8000, 10000, 13300, 16000, 20000, 26600,
-                32000, 40000, 53300, 80000
-        };
-static int RANGE_TO_REG( int range )
+static const int lm85_range_map[] = {
+        2000, 2500, 3300, 4000, 5000, 6600, 8000, 10000,
+        13300, 16000, 20000, 26600, 32000, 40000, 53300, 80000
+};
+
+static int RANGE_TO_REG(int range)
 {
         int i;
 
-        if (range >= lm85_range_map[15])
-                return 15 ;
-
         /* Find the closest match */
-        for (i = 14; i >= 0; --i) {
-                if (range >= lm85_range_map[i]) {
-                        if ((lm85_range_map[i + 1] - range) <
-                                        (range - lm85_range_map[i]))
-                                return i + 1;
-                        return i;
-                }
+        for (i = 0; i < 15; ++i) {
+                if (range <= (lm85_range_map[i] + lm85_range_map[i + 1]) / 2)
+                        break;
         }
 
-        return 0;
+        return i;
 }
-#define RANGE_FROM_REG(val) (lm85_range_map[(val)&0x0f])
+#define RANGE_FROM_REG(val)     lm85_range_map[(val) & 0x0f]
 
-/* These are the Acoustic Enhancement, or Temperature smoothing encodings
- * NOTE: The enable/disable bit is INCLUDED in these encodings as the
- *       MSB (bit 3, value 8).  If the enable bit is 0, the encoded value
- *       is ignored, or set to 0.
- */
 /* These are the PWM frequency encodings */
-static int lm85_freq_map[] = { /* .1 Hz */
-                100, 150, 230, 300, 380, 470, 620, 940
-        };
-static int FREQ_TO_REG( int freq )
+static const int lm85_freq_map[8] = { /* 1 Hz */
+        10, 15, 23, 30, 38, 47, 61, 94
+};
+static const int adm1027_freq_map[8] = { /* 1 Hz */
+        11, 15, 22, 29, 35, 44, 59, 88
+};
+
+static int FREQ_TO_REG(const int *map, int freq)
 {
         int i;
 
-        if( freq >= lm85_freq_map[7] ) { return 7 ; }
-        for( i = 0 ; i < 7 ; ++i )
-                if( freq <= lm85_freq_map[i] )
-                        break ;
-        return( i & 0x07 );
+        /* Find the closest match */
+        for (i = 0; i < 7; ++i)
+                if (freq <= (map[i] + map[i + 1]) / 2)
+                        break;
+        return i;
+}
+
+static int FREQ_FROM_REG(const int *map, u8 reg)
+{
+        return map[reg & 0x07];
 }
-#define FREQ_FROM_REG(val) (lm85_freq_map[(val)&0x07])
 
 /* Since we can't use strings, I'm abusing these numbers
  *   to stand in for the following meanings:
@@ -242,30 +220,23 @@ static int FREQ_TO_REG( int freq )
  *     -2 -- PWM responds to manual control
  */
 
-static int lm85_zone_map[] = { 1, 2, 3, -1, 0, 23, 123, -2 };
-#define ZONE_FROM_REG(val) (lm85_zone_map[((val)>>5)&0x07])
+static const int lm85_zone_map[] = { 1, 2, 3, -1, 0, 23, 123, -2 };
+#define ZONE_FROM_REG(val)      lm85_zone_map[(val) >> 5]
 
-static int ZONE_TO_REG( int zone )
+static int ZONE_TO_REG(int zone)
 {
         int i;
 
-        for( i = 0 ; i <= 7 ; ++i )
-                if( zone == lm85_zone_map[i] )
-                        break ;
-        if( i > 7 )   /* Not found. */
+        for (i = 0; i <= 7; ++i)
+                if (zone == lm85_zone_map[i])
+                        break;
+        if (i > 7)   /* Not found. */
                 i = 3;  /* Always 100% */
-        return( (i & 0x07)<<5 );
+        return i << 5;
 }
 
-#define HYST_TO_REG(val) (SENSORS_LIMIT(((val)+500)/1000,0,15))
-#define HYST_FROM_REG(val) ((val)*1000)
-
-#define OFFSET_TO_REG(val) (SENSORS_LIMIT((val)/25,-127,127))
-#define OFFSET_FROM_REG(val) ((val)*25)
-
-#define PPR_MASK(fan) (0x03<<(fan *2))
-#define PPR_TO_REG(val,fan) (SENSORS_LIMIT((val)-1,0,3)<<(fan *2))
-#define PPR_FROM_REG(val,fan) ((((val)>>(fan * 2))&0x03)+1)
+#define HYST_TO_REG(val)        SENSORS_LIMIT(((val) + 500) / 1000, 0, 15)
+#define HYST_FROM_REG(val)      ((val) * 1000)
 
 /* Chip sampling rates
  *
@@ -292,11 +263,11 @@ struct lm85_zone {
         u8 hyst;        /* Low limit hysteresis. (0-15) */
         u8 range;       /* Temp range, encoded */
         s8 critical;    /* "All fans ON" temp limit */
-        u8 off_desired; /* Actual "off" temperature specified.  Preserved 
+        u8 off_desired; /* Actual "off" temperature specified.  Preserved
                          * to prevent "drift" as other autofan control
                          * values change.
                          */
-        u8 max_desired; /* Actual "max" temperature specified.  Preserved 
+        u8 max_desired; /* Actual "max" temperature specified.  Preserved
                          * to prevent "drift" as other autofan control
                          * values change.
                          */
@@ -304,7 +275,6 @@ struct lm85_zone {
 
 struct lm85_autofan {
         u8 config;      /* Register value */
-        u8 freq;        /* PWM frequency, encoded */
         u8 min_pwm;     /* Minimum PWM value, encoded */
         u8 min_off;     /* Min PWM or OFF below "limit", flag */
 };
@@ -312,8 +282,8 @@ struct lm85_autofan {
 /* For each registered chip, we need to keep some data in memory.
    The structure is dynamically allocated. */
 struct lm85_data {
-        struct i2c_client client;
         struct device *hwmon_dev;
+        const int *freq_map;
         enum chips type;
 
         struct mutex update_lock;
@@ -327,45 +297,53 @@ struct lm85_data {
         s8 temp[3];             /* Register value */
         s8 temp_min[3];         /* Register value */
         s8 temp_max[3];         /* Register value */
-        s8 temp_offset[3];      /* Register value */
         u16 fan[4];             /* Register value */
         u16 fan_min[4];         /* Register value */
         u8 pwm[3];              /* Register value */
-        u8 spinup_ctl;          /* Register encoding, combined */
-        u8 tach_mode;           /* Register encoding, combined */
+        u8 pwm_freq[3];         /* Register encoding */
         u8 temp_ext[3];         /* Decoded values */
         u8 in_ext[8];           /* Decoded values */
-        u8 fan_ppr;             /* Register value */
-        u8 smooth[3];           /* Register encoding */
         u8 vid;                 /* Register value */
         u8 vrm;                 /* VRM version */
-        u8 syncpwm3;            /* Saved PWM3 for TACH 2,3,4 config */
-        u8 oppoint[3];          /* Register value */
-        u16 tmin_ctl;           /* Register value */
-        unsigned long therm_total; /* Cummulative therm count */
-        u8 therm_limit;         /* Register value */
         u32 alarms;             /* Register encoding, combined */
         struct lm85_autofan autofan[3];
         struct lm85_zone zone[3];
 };
 
-static int lm85_attach_adapter(struct i2c_adapter *adapter);
-static int lm85_detect(struct i2c_adapter *adapter, int address,
-                        int kind);
-static int lm85_detach_client(struct i2c_client *client);
+static int lm85_detect(struct i2c_client *client, int kind,
+                       struct i2c_board_info *info);
+static int lm85_probe(struct i2c_client *client,
+                      const struct i2c_device_id *id);
+static int lm85_remove(struct i2c_client *client);
 
 static int lm85_read_value(struct i2c_client *client, u8 reg);
-static int lm85_write_value(struct i2c_client *client, u8 reg, int value);
+static void lm85_write_value(struct i2c_client *client, u8 reg, int value);
 static struct lm85_data *lm85_update_device(struct device *dev);
-static void lm85_init_client(struct i2c_client *client);
 
 
+static const struct i2c_device_id lm85_id[] = {
+        { "adm1027", adm1027 },
+        { "adt7463", adt7463 },
+        { "lm85", any_chip },
+        { "lm85b", lm85b },
+        { "lm85c", lm85c },
+        { "emc6d100", emc6d100 },
+        { "emc6d101", emc6d100 },
+        { "emc6d102", emc6d102 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, lm85_id);
+
 static struct i2c_driver lm85_driver = {
+        .class          = I2C_CLASS_HWMON,
         .driver = {
                 .name   = "lm85",
         },
-        .attach_adapter = lm85_attach_adapter,
-        .detach_client  = lm85_detach_client,
+        .probe          = lm85_probe,
+        .remove         = lm85_remove,
+        .id_table       = lm85_id,
+        .detect         = lm85_detect,
+        .address_data   = &addr_data,
 };
 
 
@@ -375,7 +353,7 @@ static ssize_t show_fan(struct device *dev, struct device_attribute *attr,
 {
         int nr = to_sensor_dev_attr(attr)->index;
         struct lm85_data *data = lm85_update_device(dev);
-        return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan[nr]) );
+        return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr]));
 }
 
 static ssize_t show_fan_min(struct device *dev, struct device_attribute *attr,
@@ -383,7 +361,7 @@ static ssize_t show_fan_min(struct device *dev, struct device_attribute *attr,
 {
         int nr = to_sensor_dev_attr(attr)->index;
         struct lm85_data *data = lm85_update_device(dev);
-        return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan_min[nr]) );
+        return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[nr]));
 }
 
 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
@@ -414,7 +392,8 @@ show_fan_offset(4);
 
 /* vid, vrm, alarms */
 
-static ssize_t show_vid_reg(struct device *dev, struct device_attribute *attr, char *buf)
+static ssize_t show_vid_reg(struct device *dev, struct device_attribute *attr,
+                char *buf)
 {
         struct lm85_data *data = lm85_update_device(dev);
         int vid;
@@ -432,13 +411,15 @@ static ssize_t show_vid_reg(struct device *dev, struct device_attribute *attr, c
 
 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
 
-static ssize_t show_vrm_reg(struct device *dev, struct device_attribute *attr, char *buf)
+static ssize_t show_vrm_reg(struct device *dev, struct device_attribute *attr,
+                char *buf)
 {
         struct lm85_data *data = dev_get_drvdata(dev);
         return sprintf(buf, "%ld\n", (long) data->vrm);
 }
 
-static ssize_t store_vrm_reg(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+static ssize_t store_vrm_reg(struct device *dev, struct device_attribute *attr,
+                const char *buf, size_t count)
 {
         struct lm85_data *data = dev_get_drvdata(dev);
         data->vrm = simple_strtoul(buf, NULL, 10);
@@ -447,7 +428,8 @@ static ssize_t store_vrm_reg(struct device *dev, struct device_attribute *attr,
 
 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
 
-static ssize_t show_alarms_reg(struct device *dev, struct device_attribute *attr, char *buf)
+static ssize_t show_alarms_reg(struct device *dev, struct device_attribute
+                *attr, char *buf)
 {
         struct lm85_data *data = lm85_update_device(dev);
         return sprintf(buf, "%u\n", data->alarms);
@@ -488,7 +470,7 @@ static ssize_t show_pwm(struct device *dev, struct device_attribute *attr,
 {
         int nr = to_sensor_dev_attr(attr)->index;
         struct lm85_data *data = lm85_update_device(dev);
-        return sprintf(buf,"%d\n", PWM_FROM_REG(data->pwm[nr]) );
+        return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[nr]));
 }
 
 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
@@ -564,11 +546,39 @@ static ssize_t set_pwm_enable(struct device *dev, struct device_attribute
         return count;
 }
 
+static ssize_t show_pwm_freq(struct device *dev,
+                struct device_attribute *attr, char *buf)
+{
+        int nr = to_sensor_dev_attr(attr)->index;
+        struct lm85_data *data = lm85_update_device(dev);
+        return sprintf(buf, "%d\n", FREQ_FROM_REG(data->freq_map,
+                                                  data->pwm_freq[nr]));
+}
+
+static ssize_t set_pwm_freq(struct device *dev,
+                struct device_attribute *attr, const char *buf, size_t count)
+{
+        int nr = to_sensor_dev_attr(attr)->index;
+        struct i2c_client *client = to_i2c_client(dev);
+        struct lm85_data *data = i2c_get_clientdata(client);
+        long val = simple_strtol(buf, NULL, 10);
+
+        mutex_lock(&data->update_lock);
+        data->pwm_freq[nr] = FREQ_TO_REG(data->freq_map, val);
+        lm85_write_value(client, LM85_REG_AFAN_RANGE(nr),
+                (data->zone[nr].range << 4)
+                | data->pwm_freq[nr]);
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+
 #define show_pwm_reg(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)
+                show_pwm_enable, set_pwm_enable, offset - 1);           \
+static SENSOR_DEVICE_ATTR(pwm##offset##_freq, S_IRUGO | S_IWUSR,        \
+                show_pwm_freq, set_pwm_freq, offset - 1)
 
 show_pwm_reg(1);
 show_pwm_reg(2);
@@ -581,17 +591,16 @@ static ssize_t show_in(struct device *dev, struct device_attribute *attr,
 {
         int nr = to_sensor_dev_attr(attr)->index;
         struct lm85_data *data = lm85_update_device(dev);
-        return sprintf( buf, "%d\n", INSEXT_FROM_REG(nr,
-                                                     data->in[nr],
-                                                     data->in_ext[nr]));
+        return sprintf(buf, "%d\n", INSEXT_FROM_REG(nr, data->in[nr],
+                                                    data->in_ext[nr]));
 }
 
-static ssize_t show_in_min(struct device *dev,  struct device_attribute *attr,
+static ssize_t show_in_min(struct device *dev, struct device_attribute *attr,
                 char *buf)
 {
         int nr = to_sensor_dev_attr(attr)->index;
         struct lm85_data *data = lm85_update_device(dev);
-        return sprintf(buf,"%d\n", INS_FROM_REG(nr, data->in_min[nr]) );
+        return sprintf(buf, "%d\n", INS_FROM_REG(nr, data->in_min[nr]));
 }
 
 static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,
@@ -614,7 +623,7 @@ static ssize_t show_in_max(struct device *dev, struct device_attribute *attr,
 {
         int nr = to_sensor_dev_attr(attr)->index;
         struct lm85_data *data = lm85_update_device(dev);
-        return sprintf(buf,"%d\n", INS_FROM_REG(nr, data->in_max[nr]) );
+        return sprintf(buf, "%d\n", INS_FROM_REG(nr, data->in_max[nr]));
 }
 
 static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
@@ -656,8 +665,8 @@ static ssize_t show_temp(struct device *dev, struct device_attribute *attr,
 {
         int nr = to_sensor_dev_attr(attr)->index;
         struct lm85_data *data = lm85_update_device(dev);
-        return sprintf(buf,"%d\n", TEMPEXT_FROM_REG(data->temp[nr],
-                                                    data->temp_ext[nr]));
+        return sprintf(buf, "%d\n", TEMPEXT_FROM_REG(data->temp[nr],
+                                                     data->temp_ext[nr]));
 }
 
 static ssize_t show_temp_min(struct device *dev, struct device_attribute *attr,
@@ -665,7 +674,7 @@ static ssize_t show_temp_min(struct device *dev, struct device_attribute *attr,
 {
         int nr = to_sensor_dev_attr(attr)->index;
         struct lm85_data *data = lm85_update_device(dev);
-        return sprintf(buf,"%d\n", TEMP_FROM_REG(data->temp_min[nr]) );
+        return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[nr]));
 }
 
 static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr,
@@ -688,7 +697,7 @@ static ssize_t show_temp_max(struct device *dev, struct device_attribute *attr,
 {
         int nr = to_sensor_dev_attr(attr)->index;
         struct lm85_data *data = lm85_update_device(dev);
-        return sprintf(buf,"%d\n", TEMP_FROM_REG(data->temp_max[nr]) );
+        return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[nr]));
 }
 
 static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
@@ -697,7 +706,7 @@ static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
         int nr = to_sensor_dev_attr(attr)->index;
         struct i2c_client *client = to_i2c_client(dev);
         struct lm85_data *data = i2c_get_clientdata(client);
-        long val = simple_strtol(buf, NULL, 10);        
+        long val = simple_strtol(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
         data->temp_max[nr] = TEMP_TO_REG(val);
@@ -726,7 +735,7 @@ static ssize_t show_pwm_auto_channels(struct device *dev,
 {
         int nr = to_sensor_dev_attr(attr)->index;
         struct lm85_data *data = lm85_update_device(dev);
-        return sprintf(buf,"%d\n", ZONE_FROM_REG(data->autofan[nr].config));
+        return sprintf(buf, "%d\n", ZONE_FROM_REG(data->autofan[nr].config));
 }
 
 static ssize_t set_pwm_auto_channels(struct device *dev,
@@ -735,11 +744,11 @@ static ssize_t set_pwm_auto_channels(struct device *dev,
         int nr = to_sensor_dev_attr(attr)->index;
         struct i2c_client *client = to_i2c_client(dev);
         struct lm85_data *data = i2c_get_clientdata(client);
-        long val = simple_strtol(buf, NULL, 10);   
+        long val = simple_strtol(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
         data->autofan[nr].config = (data->autofan[nr].config & (~0xe0))
-                | ZONE_TO_REG(val) ;
+                | ZONE_TO_REG(val);
         lm85_write_value(client, LM85_REG_AFAN_CONFIG(nr),
                 data->autofan[nr].config);
         mutex_unlock(&data->update_lock);
@@ -751,7 +760,7 @@ static ssize_t show_pwm_auto_pwm_min(struct device *dev,
 {
         int nr = to_sensor_dev_attr(attr)->index;
         struct lm85_data *data = lm85_update_device(dev);
-        return sprintf(buf,"%d\n", PWM_FROM_REG(data->autofan[nr].min_pwm));
+        return sprintf(buf, "%d\n", PWM_FROM_REG(data->autofan[nr].min_pwm));
 }
 
 static ssize_t set_pwm_auto_pwm_min(struct device *dev,
@@ -775,7 +784,7 @@ static ssize_t show_pwm_auto_pwm_minctl(struct device *dev,
 {
         int nr = to_sensor_dev_attr(attr)->index;
         struct lm85_data *data = lm85_update_device(dev);
-        return sprintf(buf,"%d\n", data->autofan[nr].min_off);
+        return sprintf(buf, "%d\n", data->autofan[nr].min_off);
 }
 
 static ssize_t set_pwm_auto_pwm_minctl(struct device *dev,
@@ -785,41 +794,15 @@ static ssize_t set_pwm_auto_pwm_minctl(struct device *dev,
         struct i2c_client *client = to_i2c_client(dev);
         struct lm85_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
+        u8 tmp;
 
         mutex_lock(&data->update_lock);
         data->autofan[nr].min_off = val;
-        lm85_write_value(client, LM85_REG_AFAN_SPIKE1, data->smooth[0]
-                | data->syncpwm3
-                | (data->autofan[0].min_off ? 0x20 : 0)
-                | (data->autofan[1].min_off ? 0x40 : 0)
-                | (data->autofan[2].min_off ? 0x80 : 0)
-        );
-        mutex_unlock(&data->update_lock);
-        return count;
-}
-
-static ssize_t show_pwm_auto_pwm_freq(struct device *dev,
-                struct device_attribute *attr, char *buf)
-{
-        int nr = to_sensor_dev_attr(attr)->index;
-        struct lm85_data *data = lm85_update_device(dev);
-        return sprintf(buf,"%d\n", FREQ_FROM_REG(data->autofan[nr].freq));
-}
-
-static ssize_t set_pwm_auto_pwm_freq(struct device *dev,
-                struct device_attribute *attr, const char *buf, size_t count)
-{
-        int nr = to_sensor_dev_attr(attr)->index;
-        struct i2c_client *client = to_i2c_client(dev);
-        struct lm85_data *data = i2c_get_clientdata(client);
-        long val = simple_strtol(buf, NULL, 10);
-
-        mutex_lock(&data->update_lock);
-        data->autofan[nr].freq = FREQ_TO_REG(val);
-        lm85_write_value(client, LM85_REG_AFAN_RANGE(nr),
-                (data->zone[nr].range << 4)
-                | data->autofan[nr].freq
-        ); 
+        tmp = lm85_read_value(client, LM85_REG_AFAN_SPIKE1);
+        tmp &= ~(0x20 << nr);
+        if (data->autofan[nr].min_off)
+                tmp |= 0x20 << nr;
+        lm85_write_value(client, LM85_REG_AFAN_SPIKE1, tmp);
         mutex_unlock(&data->update_lock);
         return count;
 }
@@ -833,10 +816,7 @@ static SENSOR_DEVICE_ATTR(pwm##offset##_auto_pwm_min,			\
                 set_pwm_auto_pwm_min, offset - 1);                      \
 static SENSOR_DEVICE_ATTR(pwm##offset##_auto_pwm_minctl,                \
                 S_IRUGO | S_IWUSR, show_pwm_auto_pwm_minctl,            \
-                set_pwm_auto_pwm_minctl, offset - 1);                   \
-static SENSOR_DEVICE_ATTR(pwm##offset##_auto_pwm_freq,                  \
-                S_IRUGO | S_IWUSR, show_pwm_auto_pwm_freq,              \
-                set_pwm_auto_pwm_freq, offset - 1);
+                set_pwm_auto_pwm_minctl, offset - 1)
 
 pwm_auto(1);
 pwm_auto(2);
@@ -849,7 +829,7 @@ static ssize_t show_temp_auto_temp_off(struct device *dev,
 {
         int nr = to_sensor_dev_attr(attr)->index;
         struct lm85_data *data = lm85_update_device(dev);
-        return sprintf(buf,"%d\n", TEMP_FROM_REG(data->zone[nr].limit) -
+        return sprintf(buf, "%d\n", TEMP_FROM_REG(data->zone[nr].limit) -
                 HYST_FROM_REG(data->zone[nr].hyst));
 }
 
@@ -866,15 +846,13 @@ static ssize_t set_temp_auto_temp_off(struct device *dev,
         min = TEMP_FROM_REG(data->zone[nr].limit);
         data->zone[nr].off_desired = TEMP_TO_REG(val);
         data->zone[nr].hyst = HYST_TO_REG(min - val);
-        if ( nr == 0 || nr == 1 ) {
+        if (nr == 0 || nr == 1) {
                 lm85_write_value(client, LM85_REG_AFAN_HYST1,
                         (data->zone[0].hyst << 4)
-                        | data->zone[1].hyst
-                        );
+                        | data->zone[1].hyst);
         } else {
                 lm85_write_value(client, LM85_REG_AFAN_HYST2,
-                        (data->zone[2].hyst << 4)
-                );
+                        (data->zone[2].hyst << 4));
         }
         mutex_unlock(&data->update_lock);
         return count;
@@ -885,7 +863,7 @@ static ssize_t show_temp_auto_temp_min(struct device *dev,
 {
         int nr = to_sensor_dev_attr(attr)->index;
         struct lm85_data *data = lm85_update_device(dev);
-        return sprintf(buf,"%d\n", TEMP_FROM_REG(data->zone[nr].limit) );
+        return sprintf(buf, "%d\n", TEMP_FROM_REG(data->zone[nr].limit));
 }
 
 static ssize_t set_temp_auto_temp_min(struct device *dev,
@@ -907,21 +885,19 @@ static ssize_t set_temp_auto_temp_min(struct device *dev,
                 TEMP_FROM_REG(data->zone[nr].limit));
         lm85_write_value(client, LM85_REG_AFAN_RANGE(nr),
                 ((data->zone[nr].range & 0x0f) << 4)
-                | (data->autofan[nr].freq & 0x07));
+                | (data->pwm_freq[nr] & 0x07));
 
 /* Update temp_auto_hyst and temp_auto_off */
         data->zone[nr].hyst = HYST_TO_REG(TEMP_FROM_REG(
                 data->zone[nr].limit) - TEMP_FROM_REG(
                 data->zone[nr].off_desired));
-        if ( nr == 0 || nr == 1 ) {
+        if (nr == 0 || nr == 1) {
                 lm85_write_value(client, LM85_REG_AFAN_HYST1,
                         (data->zone[0].hyst << 4)
-                        | data->zone[1].hyst
-                        );
+                        | data->zone[1].hyst);
         } else {
                 lm85_write_value(client, LM85_REG_AFAN_HYST2,
-                        (data->zone[2].hyst << 4)
-                );
+                        (data->zone[2].hyst << 4));
         }
         mutex_unlock(&data->update_lock);
         return count;
@@ -932,7 +908,7 @@ static ssize_t show_temp_auto_temp_max(struct device *dev,
 {
         int nr = to_sensor_dev_attr(attr)->index;
         struct lm85_data *data = lm85_update_device(dev);
-        return sprintf(buf,"%d\n", TEMP_FROM_REG(data->zone[nr].limit) +
+        return sprintf(buf, "%d\n", TEMP_FROM_REG(data->zone[nr].limit) +
                 RANGE_FROM_REG(data->zone[nr].range));
 }
 
@@ -952,7 +928,7 @@ static ssize_t set_temp_auto_temp_max(struct device *dev,
                 val - min);
         lm85_write_value(client, LM85_REG_AFAN_RANGE(nr),
                 ((data->zone[nr].range & 0x0f) << 4)
-                | (data->autofan[nr].freq & 0x07));
+                | (data->pwm_freq[nr] & 0x07));
         mutex_unlock(&data->update_lock);
         return count;
 }
@@ -962,11 +938,11 @@ static ssize_t show_temp_auto_temp_crit(struct device *dev,
 {
         int nr = to_sensor_dev_attr(attr)->index;
         struct lm85_data *data = lm85_update_device(dev);
-        return sprintf(buf,"%d\n", TEMP_FROM_REG(data->zone[nr].critical));
+        return sprintf(buf, "%d\n", TEMP_FROM_REG(data->zone[nr].critical));
 }
 
 static ssize_t set_temp_auto_temp_crit(struct device *dev,
-                struct device_attribute *attr,const char *buf, size_t count)
+                struct device_attribute *attr, const char *buf, size_t count)
 {
         int nr = to_sensor_dev_attr(attr)->index;
         struct i2c_client *client = to_i2c_client(dev);
@@ -999,13 +975,6 @@ temp_auto(1);
 temp_auto(2);
 temp_auto(3);
 
-static int lm85_attach_adapter(struct i2c_adapter *adapter)
-{
-        if (!(adapter->class & I2C_CLASS_HWMON))
-                return 0;
-        return i2c_probe(adapter, &addr_data, lm85_detect);
-}
-
 static struct attribute *lm85_attributes[] = {
         &sensor_dev_attr_fan1_input.dev_attr.attr,
         &sensor_dev_attr_fan2_input.dev_attr.attr,
@@ -1026,6 +995,9 @@ static struct attribute *lm85_attributes[] = {
         &sensor_dev_attr_pwm1_enable.dev_attr.attr,
         &sensor_dev_attr_pwm2_enable.dev_attr.attr,
         &sensor_dev_attr_pwm3_enable.dev_attr.attr,
+        &sensor_dev_attr_pwm1_freq.dev_attr.attr,
+        &sensor_dev_attr_pwm2_freq.dev_attr.attr,
+        &sensor_dev_attr_pwm3_freq.dev_attr.attr,
 
         &sensor_dev_attr_in0_input.dev_attr.attr,
         &sensor_dev_attr_in1_input.dev_attr.attr,
@@ -1068,9 +1040,6 @@ static struct attribute *lm85_attributes[] = {
         &sensor_dev_attr_pwm1_auto_pwm_minctl.dev_attr.attr,
         &sensor_dev_attr_pwm2_auto_pwm_minctl.dev_attr.attr,
         &sensor_dev_attr_pwm3_auto_pwm_minctl.dev_attr.attr,
-        &sensor_dev_attr_pwm1_auto_pwm_freq.dev_attr.attr,
-        &sensor_dev_attr_pwm2_auto_pwm_freq.dev_attr.attr,
-        &sensor_dev_attr_pwm3_auto_pwm_freq.dev_attr.attr,
 
         &sensor_dev_attr_temp1_auto_temp_off.dev_attr.attr,
         &sensor_dev_attr_temp2_auto_temp_off.dev_attr.attr,
@@ -1127,184 +1096,190 @@ static const struct attribute_group lm85_group_in567 = {
         .attrs = lm85_attributes_in567,
 };
 
-static int lm85_detect(struct i2c_adapter *adapter, int address,
-                int kind)
+static void lm85_init_client(struct i2c_client *client)
 {
-        int company, verstep ;
-        struct i2c_client *new_client = NULL;
-        struct lm85_data *data;
-        int err = 0;
-        const char *type_name = "";
+        int value;
 
-        if (!i2c_check_functionality(adapter,
-                                        I2C_FUNC_SMBUS_BYTE_DATA)) {
-                /* We need to be able to do byte I/O */
-                goto ERROR0 ;
-        };
+        /* Start monitoring if needed */
+        value = lm85_read_value(client, LM85_REG_CONFIG);
+        if (!(value & 0x01)) {
+                dev_info(&client->dev, "Starting monitoring\n");
+                lm85_write_value(client, LM85_REG_CONFIG, value | 0x01);
+        }
+
+        /* Warn about unusual configuration bits */
+        if (value & 0x02)
+                dev_warn(&client->dev, "Device configuration is locked\n");
+        if (!(value & 0x04))
+                dev_warn(&client->dev, "Device is not ready\n");
+}
 
-        /* OK. For now, 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 access lm85_{read,write}_value. */
+/* Return 0 if detection is successful, -ENODEV otherwise */
+static int lm85_detect(struct i2c_client *client, int kind,
+                       struct i2c_board_info *info)
+{
+        struct i2c_adapter *adapter = client->adapter;
+        int address = client->addr;
+        const char *type_name;
 
-        if (!(data = kzalloc(sizeof(struct lm85_data), GFP_KERNEL))) {
-                err = -ENOMEM;
-                goto ERROR0;
+        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
+                /* We need to be able to do byte I/O */
+                return -ENODEV;
         }
 
-        new_client = &data->client;
-        i2c_set_clientdata(new_client, data);
-        new_client->addr = address;
-        new_client->adapter = adapter;
-        new_client->driver = &lm85_driver;
-        new_client->flags = 0;
-
-        /* Now, we do the remaining detection. */
-
-        company = lm85_read_value(new_client, LM85_REG_COMPANY);
-        verstep = lm85_read_value(new_client, LM85_REG_VERSTEP);
-
-        dev_dbg(&adapter->dev, "Detecting device at %d,0x%02x with"
-                " COMPANY: 0x%02x and VERSTEP: 0x%02x\n",
-                i2c_adapter_id(new_client->adapter), new_client->addr,
-                company, verstep);
-
-        /* If auto-detecting, Determine the chip type. */
-        if (kind <= 0) {
-                dev_dbg(&adapter->dev, "Autodetecting device at %d,0x%02x ...\n",
-                        i2c_adapter_id(adapter), address );
-                if( company == LM85_COMPANY_NATIONAL
-                    && verstep == LM85_VERSTEP_LM85C ) {
-                        kind = lm85c ;
-                } else if( company == LM85_COMPANY_NATIONAL
-                    && verstep == LM85_VERSTEP_LM85B ) {
-                        kind = lm85b ;
-                } else if( company == LM85_COMPANY_NATIONAL
-                    && (verstep & LM85_VERSTEP_VMASK) == LM85_VERSTEP_GENERIC ) {
-                        dev_err(&adapter->dev, "Unrecognized version/stepping 0x%02x"
-                                " Defaulting to LM85.\n", verstep);
-                        kind = any_chip ;
-                } else if( company == LM85_COMPANY_ANALOG_DEV
-                    && verstep == LM85_VERSTEP_ADM1027 ) {
-                        kind = adm1027 ;
-                } else if( company == LM85_COMPANY_ANALOG_DEV
-                    && (verstep == LM85_VERSTEP_ADT7463
-                         || verstep == LM85_VERSTEP_ADT7463C) ) {
-                        kind = adt7463 ;
-                } else if( company == LM85_COMPANY_ANALOG_DEV
-                    && (verstep & LM85_VERSTEP_VMASK) == LM85_VERSTEP_GENERIC ) {
-                        dev_err(&adapter->dev, "Unrecognized version/stepping 0x%02x"
-                                " Defaulting to Generic LM85.\n", verstep );
-                        kind = any_chip ;
-                } else if( company == LM85_COMPANY_SMSC
-                    && (verstep == LM85_VERSTEP_EMC6D100_A0
-                         || verstep == LM85_VERSTEP_EMC6D100_A1) ) {
-                        /* Unfortunately, we can't tell a '100 from a '101
-                         * from the registers.  Since a '101 is a '100
-                         * in a package with fewer pins and therefore no
-                         * 3.3V, 1.5V or 1.8V inputs, perhaps if those
-                         * inputs read 0, then it's a '101.
-                         */
-                        kind = emc6d100 ;
-                } else if( company == LM85_COMPANY_SMSC
-                    && verstep == LM85_VERSTEP_EMC6D102) {
-                        kind = emc6d102 ;
-                } else if( company == LM85_COMPANY_SMSC
-                    && (verstep & LM85_VERSTEP_VMASK) == LM85_VERSTEP_GENERIC) {
-                        dev_err(&adapter->dev, "lm85: Detected SMSC chip\n");
-                        dev_err(&adapter->dev, "lm85: Unrecognized version/stepping 0x%02x"
-                            " Defaulting to Generic LM85.\n", verstep );
-                        kind = any_chip ;
-                } else if( kind == any_chip
-                    && (verstep & LM85_VERSTEP_VMASK) == LM85_VERSTEP_GENERIC) {
-                        dev_err(&adapter->dev, "Generic LM85 Version 6 detected\n");
-                        /* Leave kind as "any_chip" */
-                } else {
-                        dev_dbg(&adapter->dev, "Autodetection failed\n");
-                        /* Not an LM85 ... */
-                        if( kind == any_chip ) {  /* User used force=x,y */
-                                dev_err(&adapter->dev, "Generic LM85 Version 6 not"
-                                        " found at %d,0x%02x. Try force_lm85c.\n",
-                                        i2c_adapter_id(adapter), address );
+        /* If auto-detecting, determine the chip type */
+        if (kind < 0) {
+                int company = lm85_read_value(client, LM85_REG_COMPANY);
+                int verstep = lm85_read_value(client, LM85_REG_VERSTEP);
+
+                dev_dbg(&adapter->dev, "Detecting device at 0x%02x with "
+                        "COMPANY: 0x%02x and VERSTEP: 0x%02x\n",
+                        address, company, verstep);
+
+                /* All supported chips have the version in common */
+                if ((verstep & LM85_VERSTEP_VMASK) != LM85_VERSTEP_GENERIC) {
+                        dev_dbg(&adapter->dev, "Autodetection failed: "
+                                "unsupported version\n");
+                        return -ENODEV;
+                }
+                kind = any_chip;
+
+                /* Now, refine the detection */
+                if (company == LM85_COMPANY_NATIONAL) {
+                        switch (verstep) {
+                        case LM85_VERSTEP_LM85C:
+                                kind = lm85c;
+                                break;
+                        case LM85_VERSTEP_LM85B:
+                                kind = lm85b;
+                                break;
+                        }
+                } else if (company == LM85_COMPANY_ANALOG_DEV) {
+                        switch (verstep) {
+                        case LM85_VERSTEP_ADM1027:
+                                kind = adm1027;
+                                break;
+                        case LM85_VERSTEP_ADT7463:
+                        case LM85_VERSTEP_ADT7463C:
+                                kind = adt7463;
+                                break;
+                        }
+                } else if (company == LM85_COMPANY_SMSC) {
+                        switch (verstep) {
+                        case LM85_VERSTEP_EMC6D100_A0:
+                        case LM85_VERSTEP_EMC6D100_A1:
+                                /* Note: we can't tell a '100 from a '101 */
+                                kind = emc6d100;
+                                break;
+                        case LM85_VERSTEP_EMC6D102:
+                                kind = emc6d102;
+                                break;
                         }
-                        err = 0 ;
-                        goto ERROR1;
+                } else {
+                        dev_dbg(&adapter->dev, "Autodetection failed: "
+                                "unknown vendor\n");
+                        return -ENODEV;
                 }
         }
 
-        /* Fill in the chip specific driver values */
-        if ( kind == any_chip ) {
-                type_name = "lm85";
-        } else if ( kind == lm85b ) {
+        switch (kind) {
+        case lm85b:
                 type_name = "lm85b";
-        } else if ( kind == lm85c ) {
+                break;
+        case lm85c:
                 type_name = "lm85c";
-        } else if ( kind == adm1027 ) {
+                break;
+        case adm1027:
                 type_name = "adm1027";
-        } else if ( kind == adt7463 ) {
+                break;
+        case adt7463:
                 type_name = "adt7463";
-        } else if ( kind == emc6d100){
+                break;
+        case emc6d100:
                 type_name = "emc6d100";
-        } else if ( kind == emc6d102 ) {
+                break;
+        case emc6d102:
                 type_name = "emc6d102";
+                break;
+        default:
+                type_name = "lm85";
         }
-        strlcpy(new_client->name, type_name, I2C_NAME_SIZE);
+        strlcpy(info->type, type_name, I2C_NAME_SIZE);
+
+        return 0;
+}
+
+static int lm85_probe(struct i2c_client *client,
+                      const struct i2c_device_id *id)
+{
+        struct lm85_data *data;
+        int err;
+
+        data = kzalloc(sizeof(struct lm85_data), GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
 
-        /* Fill in the remaining client fields */
-        data->type = kind;
-        data->valid = 0;
+        i2c_set_clientdata(client, data);
+        data->type = id->driver_data;
         mutex_init(&data->update_lock);
 
-        /* Tell the I2C layer a new client has arrived */
-        if ((err = i2c_attach_client(new_client)))
-                goto ERROR1;
+        /* Fill in the chip specific driver values */
+        switch (data->type) {
+        case adm1027:
+        case adt7463:
+        case emc6d100:
+        case emc6d102:
+                data->freq_map = adm1027_freq_map;
+                break;
+        default:
+                data->freq_map = lm85_freq_map;
+        }
 
         /* Set the VRM version */
         data->vrm = vid_which_vrm();
 
         /* Initialize the LM85 chip */
-        lm85_init_client(new_client);
+        lm85_init_client(client);
 
         /* Register sysfs hooks */
-        if ((err = sysfs_create_group(&new_client->dev.kobj, &lm85_group)))
-                goto ERROR2;
+        err = sysfs_create_group(&client->dev.kobj, &lm85_group);
+        if (err)
+                goto err_kfree;
 
         /* The ADT7463 has an optional VRM 10 mode where pin 21 is used
            as a sixth digital VID input rather than an analog input. */
-        data->vid = lm85_read_value(new_client, LM85_REG_VID);
-        if (!(kind == adt7463 && (data->vid & 0x80)))
-                if ((err = sysfs_create_group(&new_client->dev.kobj,
+        data->vid = lm85_read_value(client, LM85_REG_VID);
+        if (!(data->type == adt7463 && (data->vid & 0x80)))
+                if ((err = sysfs_create_group(&client->dev.kobj,
                                         &lm85_group_in4)))
-                        goto ERROR3;
+                        goto err_remove_files;
 
         /* The EMC6D100 has 3 additional voltage inputs */
-        if (kind == emc6d100)
-                if ((err = sysfs_create_group(&new_client->dev.kobj,
+        if (data->type == emc6d100)
+                if ((err = sysfs_create_group(&client->dev.kobj,
                                         &lm85_group_in567)))
-                        goto ERROR3;
+                        goto err_remove_files;
 
-        data->hwmon_dev = hwmon_device_register(&new_client->dev);
+        data->hwmon_dev = hwmon_device_register(&client->dev);
         if (IS_ERR(data->hwmon_dev)) {
                 err = PTR_ERR(data->hwmon_dev);
-                goto ERROR3;
+                goto err_remove_files;
         }
 
         return 0;
 
         /* Error out and cleanup code */
-    ERROR3:
-        sysfs_remove_group(&new_client->dev.kobj, &lm85_group);
-        sysfs_remove_group(&new_client->dev.kobj, &lm85_group_in4);
-        if (kind == emc6d100)
-                sysfs_remove_group(&new_client->dev.kobj, &lm85_group_in567);
-    ERROR2:
-        i2c_detach_client(new_client);
-    ERROR1:
+ err_remove_files:
+        sysfs_remove_group(&client->dev.kobj, &lm85_group);
+        sysfs_remove_group(&client->dev.kobj, &lm85_group_in4);
+        if (data->type == emc6d100)
+                sysfs_remove_group(&client->dev.kobj, &lm85_group_in567);
+ err_kfree:
         kfree(data);
-    ERROR0:
         return err;
 }
 
-static int lm85_detach_client(struct i2c_client *client)
+static int lm85_remove(struct i2c_client *client)
 {
         struct lm85_data *data = i2c_get_clientdata(client);
         hwmon_device_unregister(data->hwmon_dev);
@@ -1312,7 +1287,6 @@ static int lm85_detach_client(struct i2c_client *client)
         sysfs_remove_group(&client->dev.kobj, &lm85_group_in4);
         if (data->type == emc6d100)
                 sysfs_remove_group(&client->dev.kobj, &lm85_group_in567);
-        i2c_detach_client(client);
         kfree(data);
         return 0;
 }
@@ -1323,100 +1297,46 @@ static int lm85_read_value(struct i2c_client *client, u8 reg)
         int res;
 
         /* What size location is it? */
-        switch( reg ) {
-        case LM85_REG_FAN(0) :  /* Read WORD data */
-        case LM85_REG_FAN(1) :
-        case LM85_REG_FAN(2) :
-        case LM85_REG_FAN(3) :
-        case LM85_REG_FAN_MIN(0) :
-        case LM85_REG_FAN_MIN(1) :
-        case LM85_REG_FAN_MIN(2) :
-        case LM85_REG_FAN_MIN(3) :
-        case LM85_REG_ALARM1 :  /* Read both bytes at once */
-                res = i2c_smbus_read_byte_data(client, reg) & 0xff ;
-                res |= i2c_smbus_read_byte_data(client, reg+1) << 8 ;
-                break ;
-        case ADT7463_REG_TMIN_CTL1 :  /* Read WORD MSB, LSB */
-                res = i2c_smbus_read_byte_data(client, reg) << 8 ;
-                res |= i2c_smbus_read_byte_data(client, reg+1) & 0xff ;
-                break ;
+        switch (reg) {
+        case LM85_REG_FAN(0):  /* Read WORD data */
+        case LM85_REG_FAN(1):
+        case LM85_REG_FAN(2):
+        case LM85_REG_FAN(3):
+        case LM85_REG_FAN_MIN(0):
+        case LM85_REG_FAN_MIN(1):
+        case LM85_REG_FAN_MIN(2):
+        case LM85_REG_FAN_MIN(3):
+        case LM85_REG_ALARM1:   /* Read both bytes at once */
+                res = i2c_smbus_read_byte_data(client, reg) & 0xff;
+                res |= i2c_smbus_read_byte_data(client, reg + 1) << 8;
+                break;
         default:        /* Read BYTE data */
                 res = i2c_smbus_read_byte_data(client, reg);
-                break ;
+                break;
         }
 
-        return res ;
+        return res;
 }
 
-static int lm85_write_value(struct i2c_client *client, u8 reg, int value)
+static void lm85_write_value(struct i2c_client *client, u8 reg, int value)
 {
-        int res ;
-
-        switch( reg ) {
-        case LM85_REG_FAN(0) :  /* Write WORD data */
-        case LM85_REG_FAN(1) :
-        case LM85_REG_FAN(2) :
-        case LM85_REG_FAN(3) :
-        case LM85_REG_FAN_MIN(0) :
-        case LM85_REG_FAN_MIN(1) :
-        case LM85_REG_FAN_MIN(2) :
-        case LM85_REG_FAN_MIN(3) :
+        switch (reg) {
+        case LM85_REG_FAN(0):  /* Write WORD data */
+        case LM85_REG_FAN(1):
+        case LM85_REG_FAN(2):
+        case LM85_REG_FAN(3):
+        case LM85_REG_FAN_MIN(0):
+        case LM85_REG_FAN_MIN(1):
+        case LM85_REG_FAN_MIN(2):
+        case LM85_REG_FAN_MIN(3):
         /* NOTE: ALARM is read only, so not included here */
-                res = i2c_smbus_write_byte_data(client, reg, value & 0xff) ;
-                res |= i2c_smbus_write_byte_data(client, reg+1, (value>>8) & 0xff) ;
-                break ;
-        case ADT7463_REG_TMIN_CTL1 :  /* Write WORD MSB, LSB */
-                res = i2c_smbus_write_byte_data(client, reg, (value>>8) & 0xff);
-                res |= i2c_smbus_write_byte_data(client, reg+1, value & 0xff) ;
-                break ;
+                i2c_smbus_write_byte_data(client, reg, value & 0xff);
+                i2c_smbus_write_byte_data(client, reg + 1, value >> 8);
+                break;
         default:        /* Write BYTE data */
-                res = i2c_smbus_write_byte_data(client, reg, value);
-                break ;
+                i2c_smbus_write_byte_data(client, reg, value);
+                break;
         }
-
-        return res ;
-}
-
-static void lm85_init_client(struct i2c_client *client)
-{
-        int value;
-        struct lm85_data *data = i2c_get_clientdata(client);
-
-        dev_dbg(&client->dev, "Initializing device\n");
-
-        /* Warn if part was not "READY" */
-        value = lm85_read_value(client, LM85_REG_CONFIG);
-        dev_dbg(&client->dev, "LM85_REG_CONFIG is: 0x%02x\n", value);
-        if( value & 0x02 ) {
-                dev_err(&client->dev, "Client (%d,0x%02x) config is locked.\n",
-                            i2c_adapter_id(client->adapter), client->addr );
-        };
-        if( ! (value & 0x04) ) {
-                dev_err(&client->dev, "Client (%d,0x%02x) is not ready.\n",
-                            i2c_adapter_id(client->adapter), client->addr );
-        };
-        if( value & 0x10
-            && ( data->type == adm1027
-                || data->type == adt7463 ) ) {
-                dev_err(&client->dev, "Client (%d,0x%02x) VxI mode is set.  "
-                        "Please report this to the lm85 maintainer.\n",
-                            i2c_adapter_id(client->adapter), client->addr );
-        };
-
-        /* WE INTENTIONALLY make no changes to the limits,
-         *   offsets, pwms, fans and zones.  If they were
-         *   configured, we don't want to mess with them.
-         *   If they weren't, the default is 100% PWM, no
-         *   control and will suffice until 'sensors -s'
-         *   can be run by the user.
-         */
-
-        /* Start monitoring */
-        value = lm85_read_value(client, LM85_REG_CONFIG);
-        /* Try to clear LOCK, Set START, save everything else */
-        value = (value & ~ 0x02) | 0x01 ;
-        dev_dbg(&client->dev, "Setting CONFIG to: 0x%02x\n", value);
-        lm85_write_value(client, LM85_REG_CONFIG, value);
 }
 
 static struct lm85_data *lm85_update_device(struct device *dev)
@@ -1427,28 +1347,30 @@ static struct lm85_data *lm85_update_device(struct device *dev)
 
         mutex_lock(&data->update_lock);
 
-        if ( !data->valid ||
-             time_after(jiffies, data->last_reading + LM85_DATA_INTERVAL) ) {
+        if (!data->valid ||
+             time_after(jiffies, data->last_reading + LM85_DATA_INTERVAL)) {
                 /* Things that change quickly */
                 dev_dbg(&client->dev, "Reading sensor values\n");
-                
+
                 /* Have to read extended bits first to "freeze" the
                  * more significant bits that are read later.
                  * There are 2 additional resolution bits per channel and we
                  * have room for 4, so we shift them to the left.
                  */
-                if ( (data->type == adm1027) || (data->type == adt7463) ) {
+                if (data->type == adm1027 || data->type == adt7463) {
                         int ext1 = lm85_read_value(client,
                                                    ADM1027_REG_EXTEND_ADC1);
                         int ext2 =  lm85_read_value(client,
                                                     ADM1027_REG_EXTEND_ADC2);
                         int val = (ext1 << 8) + ext2;
 
-                        for(i = 0; i <= 4; i++)
-                                data->in_ext[i] = ((val>>(i * 2))&0x03) << 2;
+                        for (i = 0; i <= 4; i++)
+                                data->in_ext[i] =
+                                        ((val >> (i * 2)) & 0x03) << 2;
 
-                        for(i = 0; i <= 2; i++)
-                                data->temp_ext[i] = (val>>((i + 4) * 2))&0x0c;
+                        for (i = 0; i <= 2; i++)
+                                data->temp_ext[i] =
+                                        (val >> ((i + 4) * 2)) & 0x0c;
                 }
 
                 data->vid = lm85_read_value(client, LM85_REG_VID);
@@ -1456,6 +1378,8 @@ static struct lm85_data *lm85_update_device(struct device *dev)
                 for (i = 0; i <= 3; ++i) {
                         data->in[i] =
                             lm85_read_value(client, LM85_REG_IN(i));
+                        data->fan[i] =
+                            lm85_read_value(client, LM85_REG_FAN(i));
                 }
 
                 if (!(data->type == adt7463 && (data->vid & 0x80))) {
@@ -1463,38 +1387,25 @@ static struct lm85_data *lm85_update_device(struct device *dev)
                                       LM85_REG_IN(4));
                 }
 
-                for (i = 0; i <= 3; ++i) {
-                        data->fan[i] =
-                            lm85_read_value(client, LM85_REG_FAN(i));
-                }
-
                 for (i = 0; i <= 2; ++i) {
                         data->temp[i] =
                             lm85_read_value(client, LM85_REG_TEMP(i));
-                }
-
-                for (i = 0; i <= 2; ++i) {
                         data->pwm[i] =
                             lm85_read_value(client, LM85_REG_PWM(i));
                 }
 
                 data->alarms = lm85_read_value(client, LM85_REG_ALARM1);
 
-                if ( data->type == adt7463 ) {
-                        if( data->therm_total < ULONG_MAX - 256 ) {
-                            data->therm_total +=
-                                lm85_read_value(client, ADT7463_REG_THERM );
-                        }
-                } else if ( data->type == emc6d100 ) {
+                if (data->type == emc6d100) {
                         /* Three more voltage sensors */
                         for (i = 5; i <= 7; ++i) {
-                                data->in[i] =
-                                        lm85_read_value(client, EMC6D100_REG_IN(i));
+                                data->in[i] = lm85_read_value(client,
+                                                        EMC6D100_REG_IN(i));
                         }
                         /* More alarm bits */
-                        data->alarms |=
-                                lm85_read_value(client, EMC6D100_REG_ALARM3) << 16;
-                } else if (data->type == emc6d102 ) {
+                        data->alarms |= lm85_read_value(client,
+                                                EMC6D100_REG_ALARM3) << 16;
+                } else if (data->type == emc6d102) {
                         /* Have to read LSB bits after the MSB ones because
                            the reading of the MSB bits has frozen the
                            LSBs (backward from the ADM1027).
@@ -1509,20 +1420,20 @@ static struct lm85_data *lm85_update_device(struct device *dev)
                                                    EMC6D102_REG_EXTEND_ADC4);
                         data->in_ext[0] = ext3 & 0x0f;
                         data->in_ext[1] = ext4 & 0x0f;
-                        data->in_ext[2] = (ext4 >> 4) & 0x0f;
-                        data->in_ext[3] = (ext3 >> 4) & 0x0f;
-                        data->in_ext[4] = (ext2 >> 4) & 0x0f;
+                        data->in_ext[2] = ext4 >> 4;
+                        data->in_ext[3] = ext3 >> 4;
+                        data->in_ext[4] = ext2 >> 4;
 
                         data->temp_ext[0] = ext1 & 0x0f;
                         data->temp_ext[1] = ext2 & 0x0f;
-                        data->temp_ext[2] = (ext1 >> 4) & 0x0f;
+                        data->temp_ext[2] = ext1 >> 4;
                 }
 
-                data->last_reading = jiffies ;
-        };  /* last_reading */
+                data->last_reading = jiffies;
+        }  /* last_reading */
 
-        if ( !data->valid ||
-             time_after(jiffies, data->last_config + LM85_CONFIG_INTERVAL) ) {
+        if (!data->valid ||
+             time_after(jiffies, data->last_config + LM85_CONFIG_INTERVAL)) {
                 /* Things that don't change often */
                 dev_dbg(&client->dev, "Reading config values\n");
 
@@ -1531,6 +1442,8 @@ static struct lm85_data *lm85_update_device(struct device *dev)
                             lm85_read_value(client, LM85_REG_IN_MIN(i));
                         data->in_max[i] =
                             lm85_read_value(client, LM85_REG_IN_MAX(i));
+                        data->fan_min[i] =
+                            lm85_read_value(client, LM85_REG_FAN_MIN(i));
                 }
 
                 if (!(data->type == adt7463 && (data->vid & 0x80))) {
@@ -1540,34 +1453,28 @@ static struct lm85_data *lm85_update_device(struct device *dev)
                                           LM85_REG_IN_MAX(4));
                 }
 
-                if ( data->type == emc6d100 ) {
+                if (data->type == emc6d100) {
                         for (i = 5; i <= 7; ++i) {
-                                data->in_min[i] =
-                                        lm85_read_value(client, EMC6D100_REG_IN_MIN(i));
-                                data->in_max[i] =
-                                        lm85_read_value(client, EMC6D100_REG_IN_MAX(i));
+                                data->in_min[i] = lm85_read_value(client,
+                                                EMC6D100_REG_IN_MIN(i));
+                                data->in_max[i] = lm85_read_value(client,
+                                                EMC6D100_REG_IN_MAX(i));
                         }
                 }
 
-                for (i = 0; i <= 3; ++i) {
-                        data->fan_min[i] =
-                            lm85_read_value(client, LM85_REG_FAN_MIN(i));
-                }
-
                 for (i = 0; i <= 2; ++i) {
+                        int val;
+
                         data->temp_min[i] =
                             lm85_read_value(client, LM85_REG_TEMP_MIN(i));
                         data->temp_max[i] =
                             lm85_read_value(client, LM85_REG_TEMP_MAX(i));
-                }
 
-                for (i = 0; i <= 2; ++i) {
-                        int val ;
                         data->autofan[i].config =
                             lm85_read_value(client, LM85_REG_AFAN_CONFIG(i));
                         val = lm85_read_value(client, LM85_REG_AFAN_RANGE(i));
-                        data->autofan[i].freq = val & 0x07 ;
-                        data->zone[i].range = (val >> 4) & 0x0f ;
+                        data->pwm_freq[i] = val & 0x07;
+                        data->zone[i].range = val >> 4;
                         data->autofan[i].min_pwm =
                             lm85_read_value(client, LM85_REG_AFAN_MINPWM(i));
                         data->zone[i].limit =
@@ -1577,50 +1484,19 @@ static struct lm85_data *lm85_update_device(struct device *dev)
                 }
 
                 i = lm85_read_value(client, LM85_REG_AFAN_SPIKE1);
-                data->smooth[0] = i & 0x0f ;
-                data->syncpwm3 = i & 0x10 ;  /* Save PWM3 config */
-                data->autofan[0].min_off = (i & 0x20) != 0 ;
-                data->autofan[1].min_off = (i & 0x40) != 0 ;
-                data->autofan[2].min_off = (i & 0x80) != 0 ;
-                i = lm85_read_value(client, LM85_REG_AFAN_SPIKE2);
-                data->smooth[1] = (i>>4) & 0x0f ;
-                data->smooth[2] = i & 0x0f ;
+                data->autofan[0].min_off = (i & 0x20) != 0;
+                data->autofan[1].min_off = (i & 0x40) != 0;
+                data->autofan[2].min_off = (i & 0x80) != 0;
 
                 i = lm85_read_value(client, LM85_REG_AFAN_HYST1);
-                data->zone[0].hyst = (i>>4) & 0x0f ;
-                data->zone[1].hyst = i & 0x0f ;
+                data->zone[0].hyst = i >> 4;
+                data->zone[1].hyst = i & 0x0f;
 
                 i = lm85_read_value(client, LM85_REG_AFAN_HYST2);
-                data->zone[2].hyst = (i>>4) & 0x0f ;
-
-                if ( (data->type == lm85b) || (data->type == lm85c) ) {
-                        data->tach_mode = lm85_read_value(client,
-                                LM85_REG_TACH_MODE );
-                        data->spinup_ctl = lm85_read_value(client,
-                                LM85_REG_SPINUP_CTL );
-                } else if ( (data->type == adt7463) || (data->type == adm1027) ) {
-                        if ( data->type == adt7463 ) {
-                                for (i = 0; i <= 2; ++i) {
-                                    data->oppoint[i] = lm85_read_value(client,
-                                        ADT7463_REG_OPPOINT(i) );
-                                }
-                                data->tmin_ctl = lm85_read_value(client,
-                                        ADT7463_REG_TMIN_CTL1 );
-                                data->therm_limit = lm85_read_value(client,
-                                        ADT7463_REG_THERM_LIMIT );
-                        }
-                        for (i = 0; i <= 2; ++i) {
-                            data->temp_offset[i] = lm85_read_value(client,
-                                ADM1027_REG_TEMP_OFFSET(i) );
-                        }
-                        data->tach_mode = lm85_read_value(client,
-                                ADM1027_REG_CONFIG3 );
-                        data->fan_ppr = lm85_read_value(client,
-                                ADM1027_REG_FAN_PPR );
-                }
-        
+                data->zone[2].hyst = i >> 4;
+
                 data->last_config = jiffies;
-        };  /* last_config */
+        }  /* last_config */
 
         data->valid = 1;
 
@@ -1635,17 +1511,15 @@ static int __init sm_lm85_init(void)
         return i2c_add_driver(&lm85_driver);
 }
 
-static void  __exit sm_lm85_exit(void)
+static void __exit sm_lm85_exit(void)
 {
         i2c_del_driver(&lm85_driver);
 }
 
-/* Thanks to Richard Barrington for adding the LM85 to sensors-detect.
- * Thanks to Margit Schubert-While <margitsw@t-online.de> for help with
- *     post 2.7.0 CVS changes.
- */
 MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Philip Pokorny <ppokorny@penguincomputing.com>, Margit Schubert-While <margitsw@t-online.de>, Justin Thiessen <jthiessen@penguincomputing.com");
+MODULE_AUTHOR("Philip Pokorny <ppokorny@penguincomputing.com>, "
+        "Margit Schubert-While <margitsw@t-online.de>, "
+        "Justin Thiessen <jthiessen@penguincomputing.com>");
 MODULE_DESCRIPTION("LM85-B, LM85-C driver");
 
 module_init(sm_lm85_init);
diff --git a/drivers/hwmon/lm87.c b/drivers/hwmon/lm87.c
index 21970f0d53a1..2e4a3cea95f7 100644
--- a/drivers/hwmon/lm87.c
+++ b/drivers/hwmon/lm87.c
@@ -21,11 +21,10 @@
  *   http://www.national.com/pf/LM/LM87.html
  *
  * Some functions share pins, so not all functions are available at the same
- * time. Which are depends on the hardware setup. This driver assumes that
- * the BIOS configured the chip correctly. In that respect, it  differs from
- * the original driver (from lm_sensors for Linux 2.4), which would force the
- * LM87 to an arbitrary, compile-time chosen mode, regardless of the actual
- * chipset wiring.
+ * time. Which are depends on the hardware setup. This driver normally
+ * assumes that firmware configured the chip correctly. Where this is not
+ * the case, platform code must set the I2C client's platform_data to point
+ * to a u8 value to be written to the channel register.
  * For reference, here is the list of exclusive functions:
  *  - in0+in5 (default) or temp3
  *  - fan1 (default) or in6
@@ -199,6 +198,7 @@ struct lm87_data {
         unsigned long last_updated; /* In jiffies */
 
         u8 channel;             /* register value */
+        u8 config;              /* original register value */
 
         u8 in[8];               /* register value */
         u8 in_max[8];           /* register value */
@@ -832,6 +832,7 @@ exit_remove:
         sysfs_remove_group(&new_client->dev.kobj, &lm87_group);
         sysfs_remove_group(&new_client->dev.kobj, &lm87_group_opt);
 exit_free:
+        lm87_write_value(new_client, LM87_REG_CONFIG, data->config);
         kfree(data);
 exit:
         return err;
@@ -840,12 +841,17 @@ exit:
 static void lm87_init_client(struct i2c_client *client)
 {
         struct lm87_data *data = i2c_get_clientdata(client);
-        u8 config;
 
-        data->channel = lm87_read_value(client, LM87_REG_CHANNEL_MODE);
+        if (client->dev.platform_data) {
+                data->channel = *(u8 *)client->dev.platform_data;
+                lm87_write_value(client,
+                                 LM87_REG_CHANNEL_MODE, data->channel);
+        } else {
+                data->channel = lm87_read_value(client, LM87_REG_CHANNEL_MODE);
+        }
+        data->config = lm87_read_value(client, LM87_REG_CONFIG) & 0x6F;
 
-        config = lm87_read_value(client, LM87_REG_CONFIG);
-        if (!(config & 0x01)) {
+        if (!(data->config & 0x01)) {
                 int i;
 
                 /* Limits are left uninitialized after power-up */
@@ -867,11 +873,11 @@ static void lm87_init_client(struct i2c_client *client)
                         lm87_write_value(client, LM87_REG_IN_MAX(0), 0xFF);
                 }
         }
-        if ((config & 0x81) != 0x01) {
-                /* Start monitoring */
+
+        /* Make sure Start is set and INT#_Clear is clear */
+        if ((data->config & 0x09) != 0x01)
                 lm87_write_value(client, LM87_REG_CONFIG,
-                                 (config & 0xF7) | 0x01);
-        }
+                                 (data->config & 0x77) | 0x01);
 }
 
 static int lm87_remove(struct i2c_client *client)
@@ -882,6 +888,7 @@ static int lm87_remove(struct i2c_client *client)
         sysfs_remove_group(&client->dev.kobj, &lm87_group);
         sysfs_remove_group(&client->dev.kobj, &lm87_group_opt);
 
+        lm87_write_value(client, LM87_REG_CONFIG, data->config);
         kfree(data);
         return 0;
 }
diff --git a/drivers/hwmon/lm90.c b/drivers/hwmon/lm90.c
index c24fe36ac787..96a701866726 100644
--- a/drivers/hwmon/lm90.c
+++ b/drivers/hwmon/lm90.c
@@ -1,63 +1,51 @@
 /*
  * lm90.c - Part of lm_sensors, Linux kernel modules for hardware
  *          monitoring
- * Copyright (C) 2003-2006  Jean Delvare <khali@linux-fr.org>
+ * Copyright (C) 2003-2008  Jean Delvare <khali@linux-fr.org>
  *
  * Based on the lm83 driver. The LM90 is a sensor chip made by National
  * Semiconductor. It reports up to two temperatures (its own plus up to
  * one external one) with a 0.125 deg resolution (1 deg for local
- * temperature) and a 3-4 deg accuracy. Complete datasheet can be
- * obtained from National's website at:
- *   http://www.national.com/pf/LM/LM90.html
+ * temperature) and a 3-4 deg accuracy.
  *
  * This driver also supports the LM89 and LM99, two other sensor chips
  * made by National Semiconductor. Both have an increased remote
  * temperature measurement accuracy (1 degree), and the LM99
  * additionally shifts remote temperatures (measured and limits) by 16
- * degrees, which allows for higher temperatures measurement. The
- * driver doesn't handle it since it can be done easily in user-space.
- * Complete datasheets can be obtained from National's website at:
- *   http://www.national.com/pf/LM/LM89.html
- *   http://www.national.com/pf/LM/LM99.html
+ * degrees, which allows for higher temperatures measurement.
  * Note that there is no way to differentiate between both chips.
+ * When device is auto-detected, the driver will assume an LM99.
  *
  * This driver also supports the LM86, another sensor chip made by
  * National Semiconductor. It is exactly similar to the LM90 except it
  * has a higher accuracy.
- * Complete datasheet can be obtained from National's website at:
- *   http://www.national.com/pf/LM/LM86.html
  *
  * This driver also supports the ADM1032, a sensor chip made by Analog
  * Devices. That chip is similar to the LM90, with a few differences
- * that are not handled by this driver. Complete datasheet can be
- * obtained from Analog's website at:
- *   http://www.analog.com/en/prod/0,2877,ADM1032,00.html
- * Among others, it has a higher accuracy than the LM90, much like the
- * LM86 does.
+ * that are not handled by this driver. Among others, it has a higher
+ * accuracy than the LM90, much like the LM86 does.
  *
  * This driver also supports the MAX6657, MAX6658 and MAX6659 sensor
- * chips made by Maxim. These chips are similar to the LM86. Complete
- * datasheet can be obtained at Maxim's website at:
- *   http://www.maxim-ic.com/quick_view2.cfm/qv_pk/2578
+ * chips made by Maxim. These chips are similar to the LM86.
  * Note that there is no easy way to differentiate between the three
  * variants. The extra address and features of the MAX6659 are not
  * supported by this driver. These chips lack the remote temperature
  * offset feature.
  *
+ * This driver also supports the MAX6646, MAX6647 and MAX6649 chips
+ * made by Maxim.  These are again similar to the LM86, but they use
+ * unsigned temperature values and can report temperatures from 0 to
+ * 145 degrees.
+ *
  * This driver also supports the MAX6680 and MAX6681, two other sensor
  * chips made by Maxim. These are quite similar to the other Maxim
- * chips. Complete datasheet can be obtained at:
- *   http://www.maxim-ic.com/quick_view2.cfm/qv_pk/3370
- * The MAX6680 and MAX6681 only differ in the pinout so they can be
- * treated identically.
+ * chips. The MAX6680 and MAX6681 only differ in the pinout so they can
+ * be treated identically.
  *
- * This driver also supports the ADT7461 chip from Analog Devices but
- * only in its "compatability mode". If an ADT7461 chip is found but
- * is configured in non-compatible mode (where its temperature
- * register values are decoded differently) it is ignored by this
- * driver. Complete datasheet can be obtained from Analog's website
- * at:
- *   http://www.analog.com/en/prod/0,2877,ADT7461,00.html
+ * This driver also supports the ADT7461 chip from Analog Devices.
+ * It's supported in both compatibility and extended mode. It is mostly
+ * compatible with LM90 except for a data format difference for the
+ * temperature value registers.
  *
  * Since the LM90 was the first chipset supported by this driver, most
  * comments will refer to this chipset, but are actually general and
@@ -93,9 +81,10 @@
  * Addresses to scan
  * Address is fully defined internally and cannot be changed except for
  * MAX6659, MAX6680 and MAX6681.
- * LM86, LM89, LM90, LM99, ADM1032, ADM1032-1, ADT7461, MAX6657 and MAX6658
- * have address 0x4c.
- * ADM1032-2, ADT7461-2, LM89-1, and LM99-1 have address 0x4d.
+ * LM86, LM89, LM90, LM99, ADM1032, ADM1032-1, ADT7461, MAX6649, MAX6657
+ * and MAX6658 have address 0x4c.
+ * ADM1032-2, ADT7461-2, LM89-1, LM99-1 and MAX6646 have address 0x4d.
+ * MAX6647 has address 0x4e.
  * MAX6659 can have address 0x4c, 0x4d or 0x4e (unsupported).
  * MAX6680 and MAX6681 can have address 0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b,
  * 0x4c, 0x4d or 0x4e.
@@ -108,7 +97,8 @@ static const unsigned short normal_i2c[] = {
  * Insmod parameters
  */
 
-I2C_CLIENT_INSMOD_7(lm90, adm1032, lm99, lm86, max6657, adt7461, max6680);
+I2C_CLIENT_INSMOD_8(lm90, adm1032, lm99, lm86, max6657, adt7461, max6680,
+                    max6646);
 
 /*
  * The LM90 registers
@@ -149,39 +139,14 @@ I2C_CLIENT_INSMOD_7(lm90, adm1032, lm99, lm86, max6657, adt7461, max6680);
 #define LM90_REG_R_TCRIT_HYST           0x21
 #define LM90_REG_W_TCRIT_HYST           0x21
 
-/*
- * Conversions and various macros
- * For local temperatures and limits, critical limits and the hysteresis
- * value, the LM90 uses signed 8-bit values with LSB = 1 degree Celsius.
- * For remote temperatures and limits, it uses signed 11-bit values with
- * LSB = 0.125 degree Celsius, left-justified in 16-bit registers.
- */
+/* MAX6646/6647/6649/6657/6658/6659 registers */
 
-#define TEMP1_FROM_REG(val)     ((val) * 1000)
-#define TEMP1_TO_REG(val)       ((val) <= -128000 ? -128 : \
-                                 (val) >= 127000 ? 127 : \
-                                 (val) < 0 ? ((val) - 500) / 1000 : \
-                                 ((val) + 500) / 1000)
-#define TEMP2_FROM_REG(val)     ((val) / 32 * 125)
-#define TEMP2_TO_REG(val)       ((val) <= -128000 ? 0x8000 : \
-                                 (val) >= 127875 ? 0x7FE0 : \
-                                 (val) < 0 ? ((val) - 62) / 125 * 32 : \
-                                 ((val) + 62) / 125 * 32)
-#define HYST_TO_REG(val)        ((val) <= 0 ? 0 : (val) >= 30500 ? 31 : \
-                                 ((val) + 500) / 1000)
-
-/* 
- * ADT7461 is almost identical to LM90 except that attempts to write
- * values that are outside the range 0 < temp < 127 are treated as
- * the boundary value. 
- */
+#define MAX6657_REG_R_LOCAL_TEMPL       0x11
 
-#define TEMP1_TO_REG_ADT7461(val) ((val) <= 0 ? 0 : \
-                                 (val) >= 127000 ? 127 : \
-                                 ((val) + 500) / 1000)
-#define TEMP2_TO_REG_ADT7461(val) ((val) <= 0 ? 0 : \
-                                 (val) >= 127750 ? 0x7FC0 : \
-                                 ((val) + 125) / 250 * 64)
+/*
+ * Device flags
+ */
+#define LM90_FLAG_ADT7461_EXT           0x01    /* ADT7461 extended mode */
 
 /*
  * Functions declaration
@@ -204,8 +169,11 @@ static const struct i2c_device_id lm90_id[] = {
         { "adt7461", adt7461 },
         { "lm90", lm90 },
         { "lm86", lm86 },
-        { "lm89", lm99 },
-        { "lm99", lm99 },       /* Missing temperature offset */
+        { "lm89", lm86 },
+        { "lm99", lm99 },
+        { "max6646", max6646 },
+        { "max6647", max6646 },
+        { "max6649", max6646 },
         { "max6657", max6657 },
         { "max6658", max6657 },
         { "max6659", max6657 },
@@ -237,22 +205,150 @@ struct lm90_data {
         char valid; /* zero until following fields are valid */
         unsigned long last_updated; /* in jiffies */
         int kind;
+        int flags;
 
         /* registers values */
-        s8 temp8[5];    /* 0: local input
-                           1: local low limit
-                           2: local high limit
-                           3: local critical limit
-                           4: remote critical limit */
-        s16 temp11[4];  /* 0: remote input
+        s8 temp8[4];    /* 0: local low limit
+                           1: local high limit
+                           2: local critical limit
+                           3: remote critical limit */
+        s16 temp11[5];  /* 0: remote input
                            1: remote low limit
                            2: remote high limit
-                           3: remote offset (except max6657) */
+                           3: remote offset (except max6646 and max6657)
+                           4: local input */
         u8 temp_hyst;
         u8 alarms; /* bitvector */
 };
 
 /*
+ * Conversions
+ * For local temperatures and limits, critical limits and the hysteresis
+ * value, the LM90 uses signed 8-bit values with LSB = 1 degree Celsius.
+ * For remote temperatures and limits, it uses signed 11-bit values with
+ * LSB = 0.125 degree Celsius, left-justified in 16-bit registers.  Some
+ * Maxim chips use unsigned values.
+ */
+
+static inline int temp_from_s8(s8 val)
+{
+        return val * 1000;
+}
+
+static inline int temp_from_u8(u8 val)
+{
+        return val * 1000;
+}
+
+static inline int temp_from_s16(s16 val)
+{
+        return val / 32 * 125;
+}
+
+static inline int temp_from_u16(u16 val)
+{
+        return val / 32 * 125;
+}
+
+static s8 temp_to_s8(long val)
+{
+        if (val <= -128000)
+                return -128;
+        if (val >= 127000)
+                return 127;
+        if (val < 0)
+                return (val - 500) / 1000;
+        return (val + 500) / 1000;
+}
+
+static u8 temp_to_u8(long val)
+{
+        if (val <= 0)
+                return 0;
+        if (val >= 255000)
+                return 255;
+        return (val + 500) / 1000;
+}
+
+static s16 temp_to_s16(long val)
+{
+        if (val <= -128000)
+                return 0x8000;
+        if (val >= 127875)
+                return 0x7FE0;
+        if (val < 0)
+                return (val - 62) / 125 * 32;
+        return (val + 62) / 125 * 32;
+}
+
+static u8 hyst_to_reg(long val)
+{
+        if (val <= 0)
+                return 0;
+        if (val >= 30500)
+                return 31;
+        return (val + 500) / 1000;
+}
+
+/*
+ * ADT7461 in compatibility mode is almost identical to LM90 except that
+ * attempts to write values that are outside the range 0 < temp < 127 are
+ * treated as the boundary value.
+ *
+ * ADT7461 in "extended mode" operation uses unsigned integers offset by
+ * 64 (e.g., 0 -> -64 degC).  The range is restricted to -64..191 degC.
+ */
+static inline int temp_from_u8_adt7461(struct lm90_data *data, u8 val)
+{
+        if (data->flags & LM90_FLAG_ADT7461_EXT)
+                return (val - 64) * 1000;
+        else
+                return temp_from_s8(val);
+}
+
+static inline int temp_from_u16_adt7461(struct lm90_data *data, u16 val)
+{
+        if (data->flags & LM90_FLAG_ADT7461_EXT)
+                return (val - 0x4000) / 64 * 250;
+        else
+                return temp_from_s16(val);
+}
+
+static u8 temp_to_u8_adt7461(struct lm90_data *data, long val)
+{
+        if (data->flags & LM90_FLAG_ADT7461_EXT) {
+                if (val <= -64000)
+                        return 0;
+                if (val >= 191000)
+                        return 0xFF;
+                return (val + 500 + 64000) / 1000;
+        } else {
+                if (val <= 0)
+                        return 0;
+                if (val >= 127000)
+                        return 127;
+                return (val + 500) / 1000;
+        }
+}
+
+static u16 temp_to_u16_adt7461(struct lm90_data *data, long val)
+{
+        if (data->flags & LM90_FLAG_ADT7461_EXT) {
+                if (val <= -64000)
+                        return 0;
+                if (val >= 191750)
+                        return 0xFFC0;
+                return (val + 64000 + 125) / 250 * 64;
+        } else {
+                if (val <= 0)
+                        return 0;
+                if (val >= 127750)
+                        return 0x7FC0;
+                return (val + 125) / 250 * 64;
+        }
+}
+
+/*
  * Sysfs stuff
  */
 
@@ -261,7 +357,20 @@ static ssize_t show_temp8(struct device *dev, struct device_attribute *devattr,
 {
         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
         struct lm90_data *data = lm90_update_device(dev);
-        return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp8[attr->index]));
+        int temp;
+
+        if (data->kind == adt7461)
+                temp = temp_from_u8_adt7461(data, data->temp8[attr->index]);
+        else if (data->kind == max6646)
+                temp = temp_from_u8(data->temp8[attr->index]);
+        else
+                temp = temp_from_s8(data->temp8[attr->index]);
+
+        /* +16 degrees offset for temp2 for the LM99 */
+        if (data->kind == lm99 && attr->index == 3)
+                temp += 16000;
+
+        return sprintf(buf, "%d\n", temp);
 }
 
 static ssize_t set_temp8(struct device *dev, struct device_attribute *devattr,
@@ -280,12 +389,18 @@ static ssize_t set_temp8(struct device *dev, struct device_attribute *devattr,
         long val = simple_strtol(buf, NULL, 10);
         int nr = attr->index;
 
+        /* +16 degrees offset for temp2 for the LM99 */
+        if (data->kind == lm99 && attr->index == 3)
+                val -= 16000;
+
         mutex_lock(&data->update_lock);
         if (data->kind == adt7461)
-                data->temp8[nr] = TEMP1_TO_REG_ADT7461(val);
+                data->temp8[nr] = temp_to_u8_adt7461(data, val);
+        else if (data->kind == max6646)
+                data->temp8[nr] = temp_to_u8(val);
         else
-                data->temp8[nr] = TEMP1_TO_REG(val);
-        i2c_smbus_write_byte_data(client, reg[nr - 1], data->temp8[nr]);
+                data->temp8[nr] = temp_to_s8(val);
+        i2c_smbus_write_byte_data(client, reg[nr], data->temp8[nr]);
         mutex_unlock(&data->update_lock);
         return count;
 }
@@ -295,7 +410,20 @@ static ssize_t show_temp11(struct device *dev, struct device_attribute *devattr,
 {
         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
         struct lm90_data *data = lm90_update_device(dev);
-        return sprintf(buf, "%d\n", TEMP2_FROM_REG(data->temp11[attr->index]));
+        int temp;
+
+        if (data->kind == adt7461)
+                temp = temp_from_u16_adt7461(data, data->temp11[attr->index]);
+        else if (data->kind == max6646)
+                temp = temp_from_u16(data->temp11[attr->index]);
+        else
+                temp = temp_from_s16(data->temp11[attr->index]);
+
+        /* +16 degrees offset for temp2 for the LM99 */
+        if (data->kind == lm99 &&  attr->index <= 2)
+                temp += 16000;
+
+        return sprintf(buf, "%d\n", temp);
 }
 
 static ssize_t set_temp11(struct device *dev, struct device_attribute *devattr,
@@ -316,15 +444,26 @@ static ssize_t set_temp11(struct device *dev, struct device_attribute *devattr,
         long val = simple_strtol(buf, NULL, 10);
         int nr = attr->index;
 
+        /* +16 degrees offset for temp2 for the LM99 */
+        if (data->kind == lm99 && attr->index <= 2)
+                val -= 16000;
+
         mutex_lock(&data->update_lock);
         if (data->kind == adt7461)
-                data->temp11[nr] = TEMP2_TO_REG_ADT7461(val);
+                data->temp11[nr] = temp_to_u16_adt7461(data, val);
+        else if (data->kind == max6657 || data->kind == max6680)
+                data->temp11[nr] = temp_to_s8(val) << 8;
+        else if (data->kind == max6646)
+                data->temp11[nr] = temp_to_u8(val) << 8;
         else
-                data->temp11[nr] = TEMP2_TO_REG(val);
+                data->temp11[nr] = temp_to_s16(val);
+
         i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2],
                                   data->temp11[nr] >> 8);
-        i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2 + 1],
-                                  data->temp11[nr] & 0xff);
+        if (data->kind != max6657 && data->kind != max6680
+            && data->kind != max6646)
+                i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2 + 1],
+                                          data->temp11[nr] & 0xff);
         mutex_unlock(&data->update_lock);
         return count;
 }
@@ -334,8 +473,20 @@ static ssize_t show_temphyst(struct device *dev, struct device_attribute *devatt
 {
         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
         struct lm90_data *data = lm90_update_device(dev);
-        return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp8[attr->index])
-                       - TEMP1_FROM_REG(data->temp_hyst));
+        int temp;
+
+        if (data->kind == adt7461)
+                temp = temp_from_u8_adt7461(data, data->temp8[attr->index]);
+        else if (data->kind == max6646)
+                temp = temp_from_u8(data->temp8[attr->index]);
+        else
+                temp = temp_from_s8(data->temp8[attr->index]);
+
+        /* +16 degrees offset for temp2 for the LM99 */
+        if (data->kind == lm99 && attr->index == 3)
+                temp += 16000;
+
+        return sprintf(buf, "%d\n", temp - temp_from_s8(data->temp_hyst));
 }
 
 static ssize_t set_temphyst(struct device *dev, struct device_attribute *dummy,
@@ -344,12 +495,19 @@ static ssize_t set_temphyst(struct device *dev, struct device_attribute *dummy,
         struct i2c_client *client = to_i2c_client(dev);
         struct lm90_data *data = i2c_get_clientdata(client);
         long val = simple_strtol(buf, NULL, 10);
-        long hyst;
+        int temp;
 
         mutex_lock(&data->update_lock);
-        hyst = TEMP1_FROM_REG(data->temp8[3]) - val;
+        if (data->kind == adt7461)
+                temp = temp_from_u8_adt7461(data, data->temp8[2]);
+        else if (data->kind == max6646)
+                temp = temp_from_u8(data->temp8[2]);
+        else
+                temp = temp_from_s8(data->temp8[2]);
+
+        data->temp_hyst = hyst_to_reg(temp - val);
         i2c_smbus_write_byte_data(client, LM90_REG_W_TCRIT_HYST,
-                                  HYST_TO_REG(hyst));
+                                  data->temp_hyst);
         mutex_unlock(&data->update_lock);
         return count;
 }
@@ -371,23 +529,23 @@ static ssize_t show_alarm(struct device *dev, struct device_attribute
         return sprintf(buf, "%d\n", (data->alarms >> bitnr) & 1);
 }
 
-static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp8, NULL, 0);
+static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp11, NULL, 4);
 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp11, NULL, 0);
 static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp8,
-        set_temp8, 1);
+        set_temp8, 0);
 static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp11,
         set_temp11, 1);
 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp8,
-        set_temp8, 2);
+        set_temp8, 1);
 static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp11,
         set_temp11, 2);
 static SENSOR_DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp8,
-        set_temp8, 3);
+        set_temp8, 2);
 static SENSOR_DEVICE_ATTR(temp2_crit, S_IWUSR | S_IRUGO, show_temp8,
-        set_temp8, 4);
+        set_temp8, 3);
 static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO, show_temphyst,
-        set_temphyst, 3);
-static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO, show_temphyst, NULL, 4);
+        set_temphyst, 2);
+static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO, show_temphyst, NULL, 3);
 static SENSOR_DEVICE_ATTR(temp2_offset, S_IWUSR | S_IRUGO, show_temp11,
         set_temp11, 3);
 
@@ -553,6 +711,15 @@ static int lm90_detect(struct i2c_client *new_client, int kind,
                                 } else
                                 if ((chip_id & 0xF0) == 0x30) { /* LM89/LM99 */
                                         kind = lm99;
+                                        dev_info(&adapter->dev,
+                                                 "Assuming LM99 chip at "
+                                                 "0x%02x\n", address);
+                                        dev_info(&adapter->dev,
+                                                 "If it is an LM89, pass "
+                                                 "force_lm86=%d,0x%02x when "
+                                                 "loading the lm90 driver\n",
+                                                 i2c_adapter_id(adapter),
+                                                 address);
                                 } else
                                 if (address == 0x4C
                                  && (chip_id & 0xF0) == 0x10) { /* LM86 */
@@ -568,7 +735,7 @@ static int lm90_detect(struct i2c_client *new_client, int kind,
                                 kind = adm1032;
                         } else
                         if (chip_id == 0x51 /* ADT7461 */
-                         && (reg_config1 & 0x1F) == 0x00 /* check compat mode */
+                         && (reg_config1 & 0x1B) == 0x00
                          && reg_convrate <= 0x0A) {
                                 kind = adt7461;
                         }
@@ -599,13 +766,23 @@ static int lm90_detect(struct i2c_client *new_client, int kind,
                          && (reg_config1 & 0x03) == 0x00
                          && reg_convrate <= 0x07) {
                                 kind = max6680;
+                        } else
+                        /* The chip_id register of the MAX6646/6647/6649
+                         * holds the revision of the chip.
+                         * The lowest 6 bits of the config1 register are
+                         * unused and should return zero when read.
+                         */
+                        if (chip_id == 0x59
+                         && (reg_config1 & 0x3f) == 0x00
+                         && reg_convrate <= 0x07) {
+                                kind = max6646;
                         }
                 }
 
                 if (kind <= 0) { /* identification failed */
-                        dev_info(&adapter->dev,
-                            "Unsupported chip (man_id=0x%02X, "
-                            "chip_id=0x%02X).\n", man_id, chip_id);
+                        dev_dbg(&adapter->dev,
+                                "Unsupported chip at 0x%02x (man_id=0x%02X, "
+                                "chip_id=0x%02X)\n", address, man_id, chip_id);
                         return -ENODEV;
                 }
         }
@@ -629,6 +806,8 @@ static int lm90_detect(struct i2c_client *new_client, int kind,
                 name = "max6680";
         } else if (kind == adt7461) {
                 name = "adt7461";
+        } else if (kind == max6646) {
+                name = "max6646";
         }
         strlcpy(info->type, name, I2C_NAME_SIZE);
 
@@ -668,7 +847,7 @@ static int lm90_probe(struct i2c_client *new_client,
                                               &dev_attr_pec)))
                         goto exit_remove_files;
         }
-        if (data->kind != max6657) {
+        if (data->kind != max6657 && data->kind != max6646) {
                 if ((err = device_create_file(&new_client->dev,
                                 &sensor_dev_attr_temp2_offset.dev_attr)))
                         goto exit_remove_files;
@@ -707,6 +886,12 @@ static void lm90_init_client(struct i2c_client *client)
         }
         config_orig = config;
 
+        /* Check Temperature Range Select */
+        if (data->kind == adt7461) {
+                if (config & 0x04)
+                        data->flags |= LM90_FLAG_ADT7461_EXT;
+        }
+
         /*
          * Put MAX6680/MAX8881 into extended resolution (bit 0x10,
          * 0.125 degree resolution) and range (0x08, extend range
@@ -728,7 +913,7 @@ static int lm90_remove(struct i2c_client *client)
         hwmon_device_unregister(data->hwmon_dev);
         sysfs_remove_group(&client->dev.kobj, &lm90_group);
         device_remove_file(&client->dev, &dev_attr_pec);
-        if (data->kind != max6657)
+        if (data->kind != max6657 && data->kind != max6646)
                 device_remove_file(&client->dev,
                                    &sensor_dev_attr_temp2_offset.dev_attr);
 
@@ -736,6 +921,38 @@ static int lm90_remove(struct i2c_client *client)
         return 0;
 }
 
+static int lm90_read16(struct i2c_client *client, u8 regh, u8 regl, u16 *value)
+{
+        int err;
+        u8 oldh, newh, l;
+
+        /*
+         * There is a trick here. We have to read two registers to have the
+         * sensor temperature, but we have to beware a conversion could occur
+         * inbetween the readings. The datasheet says we should either use
+         * the one-shot conversion register, which we don't want to do
+         * (disables hardware monitoring) or monitor the busy bit, which is
+         * impossible (we can't read the values and monitor that bit at the
+         * exact same time). So the solution used here is to read the high
+         * byte once, then the low byte, then the high byte again. If the new
+         * high byte matches the old one, then we have a valid reading. Else
+         * we have to read the low byte again, and now we believe we have a
+         * correct reading.
+         */
+        if ((err = lm90_read_reg(client, regh, &oldh))
+         || (err = lm90_read_reg(client, regl, &l))
+         || (err = lm90_read_reg(client, regh, &newh)))
+                return err;
+        if (oldh != newh) {
+                err = lm90_read_reg(client, regl, &l);
+                if (err)
+                        return err;
+        }
+        *value = (newh << 8) | l;
+
+        return 0;
+}
+
 static struct lm90_data *lm90_update_device(struct device *dev)
 {
         struct i2c_client *client = to_i2c_client(dev);
@@ -744,49 +961,50 @@ static struct lm90_data *lm90_update_device(struct device *dev)
         mutex_lock(&data->update_lock);
 
         if (time_after(jiffies, data->last_updated + HZ * 2) || !data->valid) {
-                u8 oldh, newh, l;
+                u8 h, l;
 
                 dev_dbg(&client->dev, "Updating lm90 data.\n");
-                lm90_read_reg(client, LM90_REG_R_LOCAL_TEMP, &data->temp8[0]);
-                lm90_read_reg(client, LM90_REG_R_LOCAL_LOW, &data->temp8[1]);
-                lm90_read_reg(client, LM90_REG_R_LOCAL_HIGH, &data->temp8[2]);
-                lm90_read_reg(client, LM90_REG_R_LOCAL_CRIT, &data->temp8[3]);
-                lm90_read_reg(client, LM90_REG_R_REMOTE_CRIT, &data->temp8[4]);
+                lm90_read_reg(client, LM90_REG_R_LOCAL_LOW, &data->temp8[0]);
+                lm90_read_reg(client, LM90_REG_R_LOCAL_HIGH, &data->temp8[1]);
+                lm90_read_reg(client, LM90_REG_R_LOCAL_CRIT, &data->temp8[2]);
+                lm90_read_reg(client, LM90_REG_R_REMOTE_CRIT, &data->temp8[3]);
                 lm90_read_reg(client, LM90_REG_R_TCRIT_HYST, &data->temp_hyst);
 
-                /*
-                 * There is a trick here. We have to read two registers to
-                 * have the remote sensor temperature, but we have to beware
-                 * a conversion could occur inbetween the readings. The
-                 * datasheet says we should either use the one-shot
-                 * conversion register, which we don't want to do (disables
-                 * hardware monitoring) or monitor the busy bit, which is
-                 * impossible (we can't read the values and monitor that bit
-                 * at the exact same time). So the solution used here is to
-                 * read the high byte once, then the low byte, then the high
-                 * byte again. If the new high byte matches the old one,
-                 * then we have a valid reading. Else we have to read the low
-                 * byte again, and now we believe we have a correct reading.
-                 */
-                if (lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPH, &oldh) == 0
-                 && lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPL, &l) == 0
-                 && lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPH, &newh) == 0
-                 && (newh == oldh
-                  || lm90_read_reg(client, LM90_REG_R_REMOTE_TEMPL, &l) == 0))
-                        data->temp11[0] = (newh << 8) | l;
-
-                if (lm90_read_reg(client, LM90_REG_R_REMOTE_LOWH, &newh) == 0
-                 && lm90_read_reg(client, LM90_REG_R_REMOTE_LOWL, &l) == 0)
-                        data->temp11[1] = (newh << 8) | l;
-                if (lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHH, &newh) == 0
-                 && lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHL, &l) == 0)
-                        data->temp11[2] = (newh << 8) | l;
-                if (data->kind != max6657) {
+                if (data->kind == max6657 || data->kind == max6646) {
+                        lm90_read16(client, LM90_REG_R_LOCAL_TEMP,
+                                    MAX6657_REG_R_LOCAL_TEMPL,
+                                    &data->temp11[4]);
+                } else {
+                        if (lm90_read_reg(client, LM90_REG_R_LOCAL_TEMP,
+                                          &h) == 0)
+                                data->temp11[4] = h << 8;
+                }
+                lm90_read16(client, LM90_REG_R_REMOTE_TEMPH,
+                            LM90_REG_R_REMOTE_TEMPL, &data->temp11[0]);
+
+                if (lm90_read_reg(client, LM90_REG_R_REMOTE_LOWH, &h) == 0) {
+                        data->temp11[1] = h << 8;
+                        if (data->kind != max6657 && data->kind != max6680
+                         && data->kind != max6646
+                         && lm90_read_reg(client, LM90_REG_R_REMOTE_LOWL,
+                                          &l) == 0)
+                                data->temp11[1] |= l;
+                }
+                if (lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHH, &h) == 0) {
+                        data->temp11[2] = h << 8;
+                        if (data->kind != max6657 && data->kind != max6680
+                         && data->kind != max6646
+                         && lm90_read_reg(client, LM90_REG_R_REMOTE_HIGHL,
+                                          &l) == 0)
+                                data->temp11[2] |= l;
+                }
+
+                if (data->kind != max6657 && data->kind != max6646) {
                         if (lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSH,
-                                          &newh) == 0
+                                          &h) == 0
                          && lm90_read_reg(client, LM90_REG_R_REMOTE_OFFSL,
                                           &l) == 0)
-                                data->temp11[3] = (newh << 8) | l;
+                                data->temp11[3] = (h << 8) | l;
                 }
                 lm90_read_reg(client, LM90_REG_R_STATUS, &data->alarms);
 
diff --git a/drivers/hwmon/max1111.c b/drivers/hwmon/max1111.c
new file mode 100644
index 000000000000..bfaa665ccf32
--- /dev/null
+++ b/drivers/hwmon/max1111.c
@@ -0,0 +1,244 @@
+/*
+ * max1111.c - +2.7V, Low-Power, Multichannel, Serial 8-bit ADCs
+ *
+ * Based on arch/arm/mach-pxa/corgi_ssp.c
+ *
+ * Copyright (C) 2004-2005 Richard Purdie
+ *
+ * Copyright (C) 2008 Marvell International Ltd.
+ *      Eric Miao <eric.miao@marvell.com>
+ *
+ *  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
+ *  publishhed by the Free Software Foundation.
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/err.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+#include <linux/spi/spi.h>
+
+#define MAX1111_TX_BUF_SIZE     1
+#define MAX1111_RX_BUF_SIZE     2
+
+/* MAX1111 Commands */
+#define MAX1111_CTRL_PD0      (1u << 0)
+#define MAX1111_CTRL_PD1      (1u << 1)
+#define MAX1111_CTRL_SGL      (1u << 2)
+#define MAX1111_CTRL_UNI      (1u << 3)
+#define MAX1111_CTRL_SEL_SH   (5)       /* NOTE: bit 4 is ignored */
+#define MAX1111_CTRL_STR      (1u << 7)
+
+struct max1111_data {
+        struct spi_device       *spi;
+        struct device           *hwmon_dev;
+        struct spi_message      msg;
+        struct spi_transfer     xfer[2];
+        uint8_t *tx_buf;
+        uint8_t *rx_buf;
+};
+
+static int max1111_read(struct device *dev, int channel)
+{
+        struct max1111_data *data = dev_get_drvdata(dev);
+        uint8_t v1, v2;
+        int err;
+
+        data->tx_buf[0] = (channel << MAX1111_CTRL_SEL_SH) |
+                MAX1111_CTRL_PD0 | MAX1111_CTRL_PD1 |
+                MAX1111_CTRL_SGL | MAX1111_CTRL_UNI | MAX1111_CTRL_STR;
+
+        err = spi_sync(data->spi, &data->msg);
+        if (err < 0) {
+                dev_err(dev, "spi_sync failed with %d\n", err);
+                return err;
+        }
+
+        v1 = data->rx_buf[0];
+        v2 = data->rx_buf[1];
+
+        if ((v1 & 0xc0) || (v2 & 0x3f))
+                return -EINVAL;
+
+        return (v1 << 2) | (v2 >> 6);
+}
+
+#ifdef CONFIG_SHARPSL_PM
+static struct max1111_data *the_max1111;
+
+int max1111_read_channel(int channel)
+{
+        return max1111_read(&the_max1111->spi->dev, channel);
+}
+EXPORT_SYMBOL(max1111_read_channel);
+#endif
+
+/*
+ * NOTE: SPI devices do not have a default 'name' attribute, which is
+ * likely to be used by hwmon applications to distinguish between
+ * different devices, explicitly add a name attribute here.
+ */
+static ssize_t show_name(struct device *dev,
+                         struct device_attribute *attr, char *buf)
+{
+        return sprintf(buf, "max1111\n");
+}
+
+static ssize_t show_adc(struct device *dev,
+                        struct device_attribute *attr, char *buf)
+{
+        int channel = to_sensor_dev_attr(attr)->index;
+        int ret;
+
+        ret = max1111_read(dev, channel);
+        if (ret < 0)
+                return ret;
+
+        return sprintf(buf, "%d\n", ret);
+}
+
+#define MAX1111_ADC_ATTR(_id)           \
+        SENSOR_DEVICE_ATTR(adc##_id##_in, S_IRUGO, show_adc, NULL, _id)
+
+static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
+static MAX1111_ADC_ATTR(0);
+static MAX1111_ADC_ATTR(1);
+static MAX1111_ADC_ATTR(2);
+static MAX1111_ADC_ATTR(3);
+
+static struct attribute *max1111_attributes[] = {
+        &dev_attr_name.attr,
+        &sensor_dev_attr_adc0_in.dev_attr.attr,
+        &sensor_dev_attr_adc1_in.dev_attr.attr,
+        &sensor_dev_attr_adc2_in.dev_attr.attr,
+        &sensor_dev_attr_adc3_in.dev_attr.attr,
+        NULL,
+};
+
+static const struct attribute_group max1111_attr_group = {
+        .attrs  = max1111_attributes,
+};
+
+static int setup_transfer(struct max1111_data *data)
+{
+        struct spi_message *m;
+        struct spi_transfer *x;
+
+        data->tx_buf = kmalloc(MAX1111_TX_BUF_SIZE, GFP_KERNEL);
+        if (!data->tx_buf)
+                return -ENOMEM;
+
+        data->rx_buf = kmalloc(MAX1111_RX_BUF_SIZE, GFP_KERNEL);
+        if (!data->rx_buf) {
+                kfree(data->tx_buf);
+                return -ENOMEM;
+        }
+
+        m = &data->msg;
+        x = &data->xfer[0];
+
+        spi_message_init(m);
+
+        x->tx_buf = &data->tx_buf[0];
+        x->len = 1;
+        spi_message_add_tail(x, m);
+
+        x++;
+        x->rx_buf = &data->rx_buf[0];
+        x->len = 2;
+        spi_message_add_tail(x, m);
+
+        return 0;
+}
+
+static int __devinit max1111_probe(struct spi_device *spi)
+{
+        struct max1111_data *data;
+        int err;
+
+        spi->bits_per_word = 8;
+        spi->mode = SPI_MODE_0;
+        err = spi_setup(spi);
+        if (err < 0)
+                return err;
+
+        data = kzalloc(sizeof(struct max1111_data), GFP_KERNEL);
+        if (data == NULL) {
+                dev_err(&spi->dev, "failed to allocate memory\n");
+                return -ENOMEM;
+        }
+
+        err = setup_transfer(data);
+        if (err)
+                goto err_free_data;
+
+        data->spi = spi;
+        spi_set_drvdata(spi, data);
+
+        err = sysfs_create_group(&spi->dev.kobj, &max1111_attr_group);
+        if (err) {
+                dev_err(&spi->dev, "failed to create attribute group\n");
+                goto err_free_all;
+        }
+
+        data->hwmon_dev = hwmon_device_register(&spi->dev);
+        if (IS_ERR(data->hwmon_dev)) {
+                dev_err(&spi->dev, "failed to create hwmon device\n");
+                err = PTR_ERR(data->hwmon_dev);
+                goto err_remove;
+        }
+
+#ifdef CONFIG_SHARPSL_PM
+        the_max1111 = data;
+#endif
+        return 0;
+
+err_remove:
+        sysfs_remove_group(&spi->dev.kobj, &max1111_attr_group);
+err_free_all:
+        kfree(data->rx_buf);
+        kfree(data->tx_buf);
+err_free_data:
+        kfree(data);
+        return err;
+}
+
+static int __devexit max1111_remove(struct spi_device *spi)
+{
+        struct max1111_data *data = spi_get_drvdata(spi);
+
+        hwmon_device_unregister(data->hwmon_dev);
+        sysfs_remove_group(&spi->dev.kobj, &max1111_attr_group);
+        kfree(data->rx_buf);
+        kfree(data->tx_buf);
+        kfree(data);
+        return 0;
+}
+
+static struct spi_driver max1111_driver = {
+        .driver         = {
+                .name   = "max1111",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = max1111_probe,
+        .remove         = __devexit_p(max1111_remove),
+};
+
+static int __init max1111_init(void)
+{
+        return spi_register_driver(&max1111_driver);
+}
+module_init(max1111_init);
+
+static void __exit max1111_exit(void)
+{
+        spi_unregister_driver(&max1111_driver);
+}
+module_exit(max1111_exit);
+
+MODULE_AUTHOR("Eric Miao <eric.miao@marvell.com>");
+MODULE_DESCRIPTION("MAX1111 ADC Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/hwmon/max1619.c b/drivers/hwmon/max1619.c
index 1ab1cacad598..7897754f3a5c 100644
--- a/drivers/hwmon/max1619.c
+++ b/drivers/hwmon/max1619.c
@@ -69,11 +69,18 @@ I2C_CLIENT_INSMOD_1(max1619);
 #define MAX1619_REG_W_TCRIT_HYST        0x13
 
 /*
- * Conversions and various macros
+ * Conversions
  */
 
-#define TEMP_FROM_REG(val)      ((val & 0x80 ? val-0x100 : val) * 1000)
-#define TEMP_TO_REG(val)        ((val < 0 ? val+0x100*1000 : val) / 1000)
+static int temp_from_reg(int val)
+{
+        return (val & 0x80 ? val-0x100 : val) * 1000;
+}
+
+static int temp_to_reg(int val)
+{
+        return (val < 0 ? val+0x100*1000 : val) / 1000;
+}
 
 /*
  * Functions declaration
@@ -135,7 +142,7 @@ struct max1619_data {
 static ssize_t show_##value(struct device *dev, struct device_attribute *attr, char *buf) \
 { \
         struct max1619_data *data = max1619_update_device(dev); \
-        return sprintf(buf, "%d\n", TEMP_FROM_REG(data->value)); \
+        return sprintf(buf, "%d\n", temp_from_reg(data->value)); \
 }
 show_temp(temp_input1);
 show_temp(temp_input2);
@@ -153,7 +160,7 @@ static ssize_t set_##value(struct device *dev, struct device_attribute *attr, co
         long val = simple_strtol(buf, NULL, 10); \
  \
         mutex_lock(&data->update_lock); \
-        data->value = TEMP_TO_REG(val); \
+        data->value = temp_to_reg(val); \
         i2c_smbus_write_byte_data(client, reg, data->value); \
         mutex_unlock(&data->update_lock); \
         return count; \
diff --git a/drivers/hwmon/pc87360.c b/drivers/hwmon/pc87360.c
index 9b462bb13fa3..5fbfa34c110e 100644
--- a/drivers/hwmon/pc87360.c
+++ b/drivers/hwmon/pc87360.c
@@ -75,7 +75,8 @@ MODULE_PARM_DESC(force_id, "Override the detected device ID");
 #define FSCM    0x09    /* Logical device: fans */
 #define VLM     0x0d    /* Logical device: voltages */
 #define TMS     0x0e    /* Logical device: temperatures */
-static const u8 logdev[3] = { FSCM, VLM, TMS };
+#define LDNI_MAX 3
+static const u8 logdev[LDNI_MAX] = { FSCM, VLM, TMS };
 
 #define LD_FAN          0
 #define LD_IN           1
@@ -489,11 +490,66 @@ static struct sensor_device_attribute in_max[] = {
         SENSOR_ATTR(in10_max, S_IWUSR | S_IRUGO, show_in_max, set_in_max, 10),
 };
 
+/* (temp & vin) channel status register alarm bits (pdf sec.11.5.12) */
+#define CHAN_ALM_MIN    0x02    /* min limit crossed */
+#define CHAN_ALM_MAX    0x04    /* max limit exceeded */
+#define TEMP_ALM_CRIT   0x08    /* temp crit exceeded (temp only) */
+
+/* show_in_min/max_alarm() reads data from the per-channel status
+   register (sec 11.5.12), not the vin event status registers (sec
+   11.5.2) that (legacy) show_in_alarm() resds (via data->in_alarms) */
+
+static ssize_t show_in_min_alarm(struct device *dev,
+                        struct device_attribute *devattr, char *buf)
+{
+        struct pc87360_data *data = pc87360_update_device(dev);
+        unsigned nr = to_sensor_dev_attr(devattr)->index;
+
+        return sprintf(buf, "%u\n", !!(data->in_status[nr] & CHAN_ALM_MIN));
+}
+static ssize_t show_in_max_alarm(struct device *dev,
+                        struct device_attribute *devattr, char *buf)
+{
+        struct pc87360_data *data = pc87360_update_device(dev);
+        unsigned nr = to_sensor_dev_attr(devattr)->index;
+
+        return sprintf(buf, "%u\n", !!(data->in_status[nr] & CHAN_ALM_MAX));
+}
+
+static struct sensor_device_attribute in_min_alarm[] = {
+        SENSOR_ATTR(in0_min_alarm, S_IRUGO, show_in_min_alarm, NULL, 0),
+        SENSOR_ATTR(in1_min_alarm, S_IRUGO, show_in_min_alarm, NULL, 1),
+        SENSOR_ATTR(in2_min_alarm, S_IRUGO, show_in_min_alarm, NULL, 2),
+        SENSOR_ATTR(in3_min_alarm, S_IRUGO, show_in_min_alarm, NULL, 3),
+        SENSOR_ATTR(in4_min_alarm, S_IRUGO, show_in_min_alarm, NULL, 4),
+        SENSOR_ATTR(in5_min_alarm, S_IRUGO, show_in_min_alarm, NULL, 5),
+        SENSOR_ATTR(in6_min_alarm, S_IRUGO, show_in_min_alarm, NULL, 6),
+        SENSOR_ATTR(in7_min_alarm, S_IRUGO, show_in_min_alarm, NULL, 7),
+        SENSOR_ATTR(in8_min_alarm, S_IRUGO, show_in_min_alarm, NULL, 8),
+        SENSOR_ATTR(in9_min_alarm, S_IRUGO, show_in_min_alarm, NULL, 9),
+        SENSOR_ATTR(in10_min_alarm, S_IRUGO, show_in_min_alarm, NULL, 10),
+};
+static struct sensor_device_attribute in_max_alarm[] = {
+        SENSOR_ATTR(in0_max_alarm, S_IRUGO, show_in_max_alarm, NULL, 0),
+        SENSOR_ATTR(in1_max_alarm, S_IRUGO, show_in_max_alarm, NULL, 1),
+        SENSOR_ATTR(in2_max_alarm, S_IRUGO, show_in_max_alarm, NULL, 2),
+        SENSOR_ATTR(in3_max_alarm, S_IRUGO, show_in_max_alarm, NULL, 3),
+        SENSOR_ATTR(in4_max_alarm, S_IRUGO, show_in_max_alarm, NULL, 4),
+        SENSOR_ATTR(in5_max_alarm, S_IRUGO, show_in_max_alarm, NULL, 5),
+        SENSOR_ATTR(in6_max_alarm, S_IRUGO, show_in_max_alarm, NULL, 6),
+        SENSOR_ATTR(in7_max_alarm, S_IRUGO, show_in_max_alarm, NULL, 7),
+        SENSOR_ATTR(in8_max_alarm, S_IRUGO, show_in_max_alarm, NULL, 8),
+        SENSOR_ATTR(in9_max_alarm, S_IRUGO, show_in_max_alarm, NULL, 9),
+        SENSOR_ATTR(in10_max_alarm, S_IRUGO, show_in_max_alarm, NULL, 10),
+};
+
 #define VIN_UNIT_ATTRS(X) \
         &in_input[X].dev_attr.attr,     \
         &in_status[X].dev_attr.attr,    \
         &in_min[X].dev_attr.attr,       \
-        &in_max[X].dev_attr.attr
+        &in_max[X].dev_attr.attr,       \
+        &in_min_alarm[X].dev_attr.attr, \
+        &in_max_alarm[X].dev_attr.attr
 
 static ssize_t show_vid(struct device *dev, struct device_attribute *attr, char *buf)
 {
@@ -658,12 +714,68 @@ static struct sensor_device_attribute therm_crit[] = {
                     show_therm_crit, set_therm_crit, 2+11),
 };
 
+/* show_therm_min/max_alarm() reads data from the per-channel voltage
+   status register (sec 11.5.12) */
+
+static ssize_t show_therm_min_alarm(struct device *dev,
+                                struct device_attribute *devattr, char *buf)
+{
+        struct pc87360_data *data = pc87360_update_device(dev);
+        unsigned nr = to_sensor_dev_attr(devattr)->index;
+
+        return sprintf(buf, "%u\n", !!(data->in_status[nr] & CHAN_ALM_MIN));
+}
+static ssize_t show_therm_max_alarm(struct device *dev,
+                                struct device_attribute *devattr, char *buf)
+{
+        struct pc87360_data *data = pc87360_update_device(dev);
+        unsigned nr = to_sensor_dev_attr(devattr)->index;
+
+        return sprintf(buf, "%u\n", !!(data->in_status[nr] & CHAN_ALM_MAX));
+}
+static ssize_t show_therm_crit_alarm(struct device *dev,
+                                struct device_attribute *devattr, char *buf)
+{
+        struct pc87360_data *data = pc87360_update_device(dev);
+        unsigned nr = to_sensor_dev_attr(devattr)->index;
+
+        return sprintf(buf, "%u\n", !!(data->in_status[nr] & TEMP_ALM_CRIT));
+}
+
+static struct sensor_device_attribute therm_min_alarm[] = {
+        SENSOR_ATTR(temp4_min_alarm, S_IRUGO,
+                    show_therm_min_alarm, NULL, 0+11),
+        SENSOR_ATTR(temp5_min_alarm, S_IRUGO,
+                    show_therm_min_alarm, NULL, 1+11),
+        SENSOR_ATTR(temp6_min_alarm, S_IRUGO,
+                    show_therm_min_alarm, NULL, 2+11),
+};
+static struct sensor_device_attribute therm_max_alarm[] = {
+        SENSOR_ATTR(temp4_max_alarm, S_IRUGO,
+                    show_therm_max_alarm, NULL, 0+11),
+        SENSOR_ATTR(temp5_max_alarm, S_IRUGO,
+                    show_therm_max_alarm, NULL, 1+11),
+        SENSOR_ATTR(temp6_max_alarm, S_IRUGO,
+                    show_therm_max_alarm, NULL, 2+11),
+};
+static struct sensor_device_attribute therm_crit_alarm[] = {
+        SENSOR_ATTR(temp4_crit_alarm, S_IRUGO,
+                    show_therm_crit_alarm, NULL, 0+11),
+        SENSOR_ATTR(temp5_crit_alarm, S_IRUGO,
+                    show_therm_crit_alarm, NULL, 1+11),
+        SENSOR_ATTR(temp6_crit_alarm, S_IRUGO,
+                    show_therm_crit_alarm, NULL, 2+11),
+};
+
 #define THERM_UNIT_ATTRS(X) \
         &therm_input[X].dev_attr.attr,  \
         &therm_status[X].dev_attr.attr, \
         &therm_min[X].dev_attr.attr,    \
         &therm_max[X].dev_attr.attr,    \
-        &therm_crit[X].dev_attr.attr
+        &therm_crit[X].dev_attr.attr,   \
+        &therm_min_alarm[X].dev_attr.attr, \
+        &therm_max_alarm[X].dev_attr.attr, \
+        &therm_crit_alarm[X].dev_attr.attr
 
 static struct attribute * pc8736x_therm_attr_array[] = {
         THERM_UNIT_ATTRS(0),
@@ -790,12 +902,76 @@ static ssize_t show_temp_alarms(struct device *dev, struct device_attribute *att
 }
 static DEVICE_ATTR(alarms_temp, S_IRUGO, show_temp_alarms, NULL);
 
+/* show_temp_min/max_alarm() reads data from the per-channel status
+   register (sec 12.3.7), not the temp event status registers (sec
+   12.3.2) that show_temp_alarm() reads (via data->temp_alarms) */
+
+static ssize_t show_temp_min_alarm(struct device *dev,
+                        struct device_attribute *devattr, char *buf)
+{
+        struct pc87360_data *data = pc87360_update_device(dev);
+        unsigned nr = to_sensor_dev_attr(devattr)->index;
+
+        return sprintf(buf, "%u\n", !!(data->temp_status[nr] & CHAN_ALM_MIN));
+}
+static ssize_t show_temp_max_alarm(struct device *dev,
+                        struct device_attribute *devattr, char *buf)
+{
+        struct pc87360_data *data = pc87360_update_device(dev);
+        unsigned nr = to_sensor_dev_attr(devattr)->index;
+
+        return sprintf(buf, "%u\n", !!(data->temp_status[nr] & CHAN_ALM_MAX));
+}
+static ssize_t show_temp_crit_alarm(struct device *dev,
+                        struct device_attribute *devattr, char *buf)
+{
+        struct pc87360_data *data = pc87360_update_device(dev);
+        unsigned nr = to_sensor_dev_attr(devattr)->index;
+
+        return sprintf(buf, "%u\n", !!(data->temp_status[nr] & TEMP_ALM_CRIT));
+}
+
+static struct sensor_device_attribute temp_min_alarm[] = {
+        SENSOR_ATTR(temp1_min_alarm, S_IRUGO, show_temp_min_alarm, NULL, 0),
+        SENSOR_ATTR(temp2_min_alarm, S_IRUGO, show_temp_min_alarm, NULL, 1),
+        SENSOR_ATTR(temp3_min_alarm, S_IRUGO, show_temp_min_alarm, NULL, 2),
+};
+static struct sensor_device_attribute temp_max_alarm[] = {
+        SENSOR_ATTR(temp1_max_alarm, S_IRUGO, show_temp_max_alarm, NULL, 0),
+        SENSOR_ATTR(temp2_max_alarm, S_IRUGO, show_temp_max_alarm, NULL, 1),
+        SENSOR_ATTR(temp3_max_alarm, S_IRUGO, show_temp_max_alarm, NULL, 2),
+};
+static struct sensor_device_attribute temp_crit_alarm[] = {
+        SENSOR_ATTR(temp1_crit_alarm, S_IRUGO, show_temp_crit_alarm, NULL, 0),
+        SENSOR_ATTR(temp2_crit_alarm, S_IRUGO, show_temp_crit_alarm, NULL, 1),
+        SENSOR_ATTR(temp3_crit_alarm, S_IRUGO, show_temp_crit_alarm, NULL, 2),
+};
+
+#define TEMP_FAULT      0x40    /* open diode */
+static ssize_t show_temp_fault(struct device *dev,
+                        struct device_attribute *devattr, char *buf)
+{
+        struct pc87360_data *data = pc87360_update_device(dev);
+        unsigned nr = to_sensor_dev_attr(devattr)->index;
+
+        return sprintf(buf, "%u\n", !!(data->temp_status[nr] & TEMP_FAULT));
+}
+static struct sensor_device_attribute temp_fault[] = {
+        SENSOR_ATTR(temp1_fault, S_IRUGO, show_temp_fault, NULL, 0),
+        SENSOR_ATTR(temp2_fault, S_IRUGO, show_temp_fault, NULL, 1),
+        SENSOR_ATTR(temp3_fault, S_IRUGO, show_temp_fault, NULL, 2),
+};
+
 #define TEMP_UNIT_ATTRS(X) \
         &temp_input[X].dev_attr.attr,   \
         &temp_status[X].dev_attr.attr,  \
         &temp_min[X].dev_attr.attr,     \
         &temp_max[X].dev_attr.attr,     \
-        &temp_crit[X].dev_attr.attr
+        &temp_crit[X].dev_attr.attr,    \
+        &temp_min_alarm[X].dev_attr.attr, \
+        &temp_max_alarm[X].dev_attr.attr, \
+        &temp_crit_alarm[X].dev_attr.attr, \
+        &temp_fault[X].dev_attr.attr
 
 static struct attribute * pc8736x_temp_attr_array[] = {
         TEMP_UNIT_ATTRS(0),
@@ -809,8 +985,8 @@ static const struct attribute_group pc8736x_temp_group = {
         .attrs = pc8736x_temp_attr_array,
 };
 
-static ssize_t show_name(struct device *dev, struct device_attribute
-                         *devattr, char *buf)
+static ssize_t show_name(struct device *dev,
+                        struct device_attribute *devattr, char *buf)
 {
         struct pc87360_data *data = dev_get_drvdata(dev);
         return sprintf(buf, "%s\n", data->name);
@@ -955,7 +1131,7 @@ static int __devinit pc87360_probe(struct platform_device *pdev)
         mutex_init(&data->update_lock);
         platform_set_drvdata(pdev, data);
 
-        for (i = 0; i < 3; i++) {
+        for (i = 0; i < LDNI_MAX; i++) {
                 if (((data->address[i] = extra_isa[i]))
                  && !request_region(extra_isa[i], PC87360_EXTENT,
                                     pc87360_driver.driver.name)) {
@@ -1031,7 +1207,15 @@ static int __devinit pc87360_probe(struct platform_device *pdev)
                             || (err = device_create_file(dev,
                                         &temp_crit[i].dev_attr))
                             || (err = device_create_file(dev,
-                                        &temp_status[i].dev_attr)))
+                                        &temp_status[i].dev_attr))
+                            || (err = device_create_file(dev,
+                                        &temp_min_alarm[i].dev_attr))
+                            || (err = device_create_file(dev,
+                                        &temp_max_alarm[i].dev_attr))
+                            || (err = device_create_file(dev,
+                                        &temp_crit_alarm[i].dev_attr))
+                            || (err = device_create_file(dev,
+                                        &temp_fault[i].dev_attr)))
                                 goto ERROR3;
                 }
                 if ((err = device_create_file(dev, &dev_attr_alarms_temp)))
@@ -1131,6 +1315,16 @@ static void pc87360_write_value(struct pc87360_data *data, u8 ldi, u8 bank,
         mutex_unlock(&(data->lock));
 }
 
+/* (temp & vin) channel conversion status register flags (pdf sec.11.5.12) */
+#define CHAN_CNVRTD     0x80    /* new data ready */
+#define CHAN_ENA        0x01    /* enabled channel (temp or vin) */
+#define CHAN_ALM_ENA    0x10    /* propagate to alarms-reg ?? (chk val!) */
+#define CHAN_READY      (CHAN_ENA|CHAN_CNVRTD) /* sample ready mask */
+
+#define TEMP_OTS_OE     0x20    /* OTS Output Enable */
+#define VIN_RW1C_MASK   (CHAN_READY|CHAN_ALM_MAX|CHAN_ALM_MIN)   /* 0x87 */
+#define TEMP_RW1C_MASK  (VIN_RW1C_MASK|TEMP_ALM_CRIT|TEMP_FAULT) /* 0xCF */
+
 static void pc87360_init_device(struct platform_device *pdev,
                                 int use_thermistors)
 {
@@ -1152,11 +1346,12 @@ static void pc87360_init_device(struct platform_device *pdev,
 
         nr = data->innr < 11 ? data->innr : 11;
         for (i = 0; i < nr; i++) {
+                reg = pc87360_read_value(data, LD_IN, i,
+                                         PC87365_REG_IN_STATUS);
+                dev_dbg(&pdev->dev, "bios in%d status:0x%02x\n", i, reg);
                 if (init >= init_in[i]) {
                         /* Forcibly enable voltage channel */
-                        reg = pc87360_read_value(data, LD_IN, i,
-                                                 PC87365_REG_IN_STATUS);
-                        if (!(reg & 0x01)) {
+                        if (!(reg & CHAN_ENA)) {
                                 dev_dbg(&pdev->dev, "Forcibly "
                                         "enabling in%d\n", i);
                                 pc87360_write_value(data, LD_IN, i,
@@ -1168,19 +1363,24 @@ static void pc87360_init_device(struct platform_device *pdev,
 
         /* We can't blindly trust the Super-I/O space configuration bit,
            most BIOS won't set it properly */
+        dev_dbg(&pdev->dev, "bios thermistors:%d\n", use_thermistors);
         for (i = 11; i < data->innr; i++) {
                 reg = pc87360_read_value(data, LD_IN, i,
                                          PC87365_REG_TEMP_STATUS);
-                use_thermistors = use_thermistors || (reg & 0x01);
+                use_thermistors = use_thermistors || (reg & CHAN_ENA);
+                /* thermistors are temp[4-6], measured on vin[11-14] */
+                dev_dbg(&pdev->dev, "bios temp%d_status:0x%02x\n", i-7, reg);
         }
+        dev_dbg(&pdev->dev, "using thermistors:%d\n", use_thermistors);
 
         i = use_thermistors ? 2 : 0;
         for (; i < data->tempnr; i++) {
+                reg = pc87360_read_value(data, LD_TEMP, i,
+                                         PC87365_REG_TEMP_STATUS);
+                dev_dbg(&pdev->dev, "bios temp%d_status:0x%02x\n", i+1, reg);
                 if (init >= init_temp[i]) {
                         /* Forcibly enable temperature channel */
-                        reg = pc87360_read_value(data, LD_TEMP, i,
-                                                 PC87365_REG_TEMP_STATUS);
-                        if (!(reg & 0x01)) {
+                        if (!(reg & CHAN_ENA)) {
                                 dev_dbg(&pdev->dev, "Forcibly "
                                         "enabling temp%d\n", i+1);
                                 pc87360_write_value(data, LD_TEMP, i,
@@ -1197,7 +1397,7 @@ static void pc87360_init_device(struct platform_device *pdev,
                                    diodes */
                                 reg = pc87360_read_value(data, LD_TEMP,
                                       (i-11)/2, PC87365_REG_TEMP_STATUS);
-                                if (reg & 0x01) {
+                                if (reg & CHAN_ENA) {
                                         dev_dbg(&pdev->dev, "Skipping "
                                                 "temp%d, pin already in use "
                                                 "by temp%d\n", i-7, (i-11)/2);
@@ -1207,7 +1407,7 @@ static void pc87360_init_device(struct platform_device *pdev,
                                 /* Forcibly enable thermistor channel */
                                 reg = pc87360_read_value(data, LD_IN, i,
                                                          PC87365_REG_IN_STATUS);
-                                if (!(reg & 0x01)) {
+                                if (!(reg & CHAN_ENA)) {
                                         dev_dbg(&pdev->dev, "Forcibly "
                                                 "enabling temp%d\n", i-7);
                                         pc87360_write_value(data, LD_IN, i,
@@ -1221,7 +1421,8 @@ static void pc87360_init_device(struct platform_device *pdev,
         if (data->innr) {
                 reg = pc87360_read_value(data, LD_IN, NO_BANK,
                                          PC87365_REG_IN_CONFIG);
-                if (reg & 0x01) {
+                dev_dbg(&pdev->dev, "bios vin-cfg:0x%02x\n", reg);
+                if (reg & CHAN_ENA) {
                         dev_dbg(&pdev->dev, "Forcibly "
                                 "enabling monitoring (VLM)\n");
                         pc87360_write_value(data, LD_IN, NO_BANK,
@@ -1233,7 +1434,8 @@ static void pc87360_init_device(struct platform_device *pdev,
         if (data->tempnr) {
                 reg = pc87360_read_value(data, LD_TEMP, NO_BANK,
                                          PC87365_REG_TEMP_CONFIG);
-                if (reg & 0x01) {
+                dev_dbg(&pdev->dev, "bios temp-cfg:0x%02x\n", reg);
+                if (reg & CHAN_ENA) {
                         dev_dbg(&pdev->dev, "Forcibly enabling "
                                 "monitoring (TMS)\n");
                         pc87360_write_value(data, LD_TEMP, NO_BANK,
@@ -1336,11 +1538,11 @@ static struct pc87360_data *pc87360_update_device(struct device *dev)
                         pc87360_write_value(data, LD_IN, i,
                                             PC87365_REG_IN_STATUS,
                                             data->in_status[i]);
-                        if ((data->in_status[i] & 0x81) == 0x81) {
+                        if ((data->in_status[i] & CHAN_READY) == CHAN_READY) {
                                 data->in[i] = pc87360_read_value(data, LD_IN,
                                               i, PC87365_REG_IN);
                         }
-                        if (data->in_status[i] & 0x01) {
+                        if (data->in_status[i] & CHAN_ENA) {
                                 data->in_min[i] = pc87360_read_value(data,
                                                   LD_IN, i,
                                                   PC87365_REG_IN_MIN);
@@ -1373,12 +1575,12 @@ static struct pc87360_data *pc87360_update_device(struct device *dev)
                         pc87360_write_value(data, LD_TEMP, i,
                                             PC87365_REG_TEMP_STATUS,
                                             data->temp_status[i]);
-                        if ((data->temp_status[i] & 0x81) == 0x81) {
+                        if ((data->temp_status[i] & CHAN_READY) == CHAN_READY) {
                                 data->temp[i] = pc87360_read_value(data,
                                                 LD_TEMP, i,
                                                 PC87365_REG_TEMP);
                         }
-                        if (data->temp_status[i] & 0x01) {
+                        if (data->temp_status[i] & CHAN_ENA) {
                                 data->temp_min[i] = pc87360_read_value(data,
                                                     LD_TEMP, i,
                                                     PC87365_REG_TEMP_MIN);
diff --git a/drivers/hwmon/thmc50.c b/drivers/hwmon/thmc50.c
index 3b01001108c1..7d97431e132f 100644
--- a/drivers/hwmon/thmc50.c
+++ b/drivers/hwmon/thmc50.c
@@ -55,8 +55,11 @@ I2C_CLIENT_MODULE_PARM(adm1022_temp3, "List of adapter,address pairs "
 static const u8 THMC50_REG_TEMP[] = { 0x27, 0x26, 0x20 };
 static const u8 THMC50_REG_TEMP_MIN[] = { 0x3A, 0x38, 0x2C };
 static const u8 THMC50_REG_TEMP_MAX[] = { 0x39, 0x37, 0x2B };
+static const u8 THMC50_REG_TEMP_CRITICAL[] = { 0x13, 0x14, 0x14 };
+static const u8 THMC50_REG_TEMP_DEFAULT[] = { 0x17, 0x18, 0x18 };
 
 #define THMC50_REG_CONF_nFANOFF                 0x20
+#define THMC50_REG_CONF_PROGRAMMED              0x08
 
 /* Each client has this additional data */
 struct thmc50_data {
@@ -72,6 +75,7 @@ struct thmc50_data {
         s8 temp_input[3];
         s8 temp_max[3];
         s8 temp_min[3];
+        s8 temp_critical[3];
         u8 analog_out;
         u8 alarms;
 };
@@ -199,6 +203,15 @@ static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
         return count;
 }
 
+static ssize_t show_temp_critical(struct device *dev,
+                                  struct device_attribute *attr,
+                                  char *buf)
+{
+        int nr = to_sensor_dev_attr(attr)->index;
+        struct thmc50_data *data = thmc50_update_device(dev);
+        return sprintf(buf, "%d\n", data->temp_critical[nr] * 1000);
+}
+
 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
                           char *buf)
 {
@@ -214,7 +227,9 @@ static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO, show_temp,	\
 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);
+                        show_temp_max, set_temp_max, offset - 1);       \
+static SENSOR_DEVICE_ATTR(temp##offset##_crit, S_IRUGO,                 \
+                        show_temp_critical, NULL, offset - 1);
 
 temp_reg(1);
 temp_reg(2);
@@ -234,10 +249,12 @@ static struct attribute *thmc50_attributes[] = {
         &sensor_dev_attr_temp1_max.dev_attr.attr,
         &sensor_dev_attr_temp1_min.dev_attr.attr,
         &sensor_dev_attr_temp1_input.dev_attr.attr,
+        &sensor_dev_attr_temp1_crit.dev_attr.attr,
         &sensor_dev_attr_temp1_alarm.dev_attr.attr,
         &sensor_dev_attr_temp2_max.dev_attr.attr,
         &sensor_dev_attr_temp2_min.dev_attr.attr,
         &sensor_dev_attr_temp2_input.dev_attr.attr,
+        &sensor_dev_attr_temp2_crit.dev_attr.attr,
         &sensor_dev_attr_temp2_alarm.dev_attr.attr,
         &sensor_dev_attr_temp2_fault.dev_attr.attr,
         &sensor_dev_attr_pwm1.dev_attr.attr,
@@ -254,6 +271,7 @@ static struct attribute *temp3_attributes[] = {
         &sensor_dev_attr_temp3_max.dev_attr.attr,
         &sensor_dev_attr_temp3_min.dev_attr.attr,
         &sensor_dev_attr_temp3_input.dev_attr.attr,
+        &sensor_dev_attr_temp3_crit.dev_attr.attr,
         &sensor_dev_attr_temp3_alarm.dev_attr.attr,
         &sensor_dev_attr_temp3_fault.dev_attr.attr,
         NULL
@@ -429,6 +447,10 @@ static struct thmc50_data *thmc50_update_device(struct device *dev)
 
                 int temps = data->has_temp3 ? 3 : 2;
                 int i;
+                int prog = i2c_smbus_read_byte_data(client, THMC50_REG_CONF);
+
+                prog &= THMC50_REG_CONF_PROGRAMMED;
+
                 for (i = 0; i < temps; i++) {
                         data->temp_input[i] = i2c_smbus_read_byte_data(client,
                                                 THMC50_REG_TEMP[i]);
@@ -436,6 +458,10 @@ static struct thmc50_data *thmc50_update_device(struct device *dev)
                                                 THMC50_REG_TEMP_MAX[i]);
                         data->temp_min[i] = i2c_smbus_read_byte_data(client,
                                                 THMC50_REG_TEMP_MIN[i]);
+                        data->temp_critical[i] =
+                                i2c_smbus_read_byte_data(client,
+                                        prog ? THMC50_REG_TEMP_CRITICAL[i]
+                                             : THMC50_REG_TEMP_DEFAULT[i]);
                 }
                 data->analog_out =
                     i2c_smbus_read_byte_data(client, THMC50_REG_ANALOG_OUT);
diff --git a/drivers/hwmon/ultra45_env.c b/drivers/hwmon/ultra45_env.c
new file mode 100644
index 000000000000..68e90abeba96
--- /dev/null
+++ b/drivers/hwmon/ultra45_env.c
@@ -0,0 +1,320 @@
+/* ultra45_env.c: Driver for Ultra45 PIC16F747 environmental monitor.
+ *
+ * Copyright (C) 2008 David S. Miller <davem@davemloft.net>
+ */
+
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/slab.h>
+#include <linux/of_device.h>
+#include <linux/io.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+
+#define DRV_MODULE_VERSION      "0.1"
+
+MODULE_AUTHOR("David S. Miller (davem@davemloft.net)");
+MODULE_DESCRIPTION("Ultra45 environmental monitor driver");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(DRV_MODULE_VERSION);
+
+/* PIC device registers */
+#define REG_CMD         0x00UL
+#define  REG_CMD_RESET  0x80
+#define  REG_CMD_ESTAR  0x01
+#define REG_STAT        0x01UL
+#define  REG_STAT_FWVER 0xf0
+#define  REG_STAT_TGOOD 0x08
+#define  REG_STAT_STALE 0x04
+#define  REG_STAT_BUSY  0x02
+#define  REG_STAT_FAULT 0x01
+#define REG_DATA        0x40UL
+#define REG_ADDR        0x41UL
+#define REG_SIZE        0x42UL
+
+/* Registers accessed indirectly via REG_DATA/REG_ADDR */
+#define IREG_FAN0               0x00
+#define IREG_FAN1               0x01
+#define IREG_FAN2               0x02
+#define IREG_FAN3               0x03
+#define IREG_FAN4               0x04
+#define IREG_FAN5               0x05
+#define IREG_LCL_TEMP           0x06
+#define IREG_RMT1_TEMP          0x07
+#define IREG_RMT2_TEMP          0x08
+#define IREG_RMT3_TEMP          0x09
+#define IREG_LM95221_TEMP       0x0a
+#define IREG_FIRE_TEMP          0x0b
+#define IREG_LSI1064_TEMP       0x0c
+#define IREG_FRONT_TEMP         0x0d
+#define IREG_FAN_STAT           0x0e
+#define IREG_VCORE0             0x0f
+#define IREG_VCORE1             0x10
+#define IREG_VMEM0              0x11
+#define IREG_VMEM1              0x12
+#define IREG_PSU_TEMP           0x13
+
+struct env {
+        void __iomem    *regs;
+        spinlock_t      lock;
+
+        struct device   *hwmon_dev;
+};
+
+static u8 env_read(struct env *p, u8 ireg)
+{
+        u8 ret;
+
+        spin_lock(&p->lock);
+        writeb(ireg, p->regs + REG_ADDR);
+        ret = readb(p->regs + REG_DATA);
+        spin_unlock(&p->lock);
+
+        return ret;
+}
+
+static void env_write(struct env *p, u8 ireg, u8 val)
+{
+        spin_lock(&p->lock);
+        writeb(ireg, p->regs + REG_ADDR);
+        writeb(val, p->regs + REG_DATA);
+        spin_unlock(&p->lock);
+}
+
+/* There seems to be a adr7462 providing these values, thus a lot
+ * of these calculations are borrowed from the adt7470 driver.
+ */
+#define FAN_PERIOD_TO_RPM(x)    ((90000 * 60) / (x))
+#define FAN_RPM_TO_PERIOD       FAN_PERIOD_TO_RPM
+#define FAN_PERIOD_INVALID      (0xff << 8)
+#define FAN_DATA_VALID(x)       ((x) && (x) != FAN_PERIOD_INVALID)
+
+static ssize_t show_fan_speed(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        int fan_nr = to_sensor_dev_attr(attr)->index;
+        struct env *p = dev_get_drvdata(dev);
+        int rpm, period;
+        u8 val;
+
+        val = env_read(p, IREG_FAN0 + fan_nr);
+        period = (int) val << 8;
+        if (FAN_DATA_VALID(period))
+                rpm = FAN_PERIOD_TO_RPM(period);
+        else
+                rpm = 0;
+
+        return sprintf(buf, "%d\n", rpm);
+}
+
+static ssize_t set_fan_speed(struct device *dev, struct device_attribute *attr,
+                             const char *buf, size_t count)
+{
+        int fan_nr = to_sensor_dev_attr(attr)->index;
+        int rpm = simple_strtol(buf, NULL, 10);
+        struct env *p = dev_get_drvdata(dev);
+        int period;
+        u8 val;
+
+        if (!rpm)
+                return -EINVAL;
+
+        period = FAN_RPM_TO_PERIOD(rpm);
+        val = period >> 8;
+        env_write(p, IREG_FAN0 + fan_nr, val);
+
+        return count;
+}
+
+static ssize_t show_fan_fault(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        int fan_nr = to_sensor_dev_attr(attr)->index;
+        struct env *p = dev_get_drvdata(dev);
+        u8 val = env_read(p, IREG_FAN_STAT);
+        return sprintf(buf, "%d\n", (val & (1 << fan_nr)) ? 1 : 0);
+}
+
+#define fan(index)                                                      \
+static SENSOR_DEVICE_ATTR(fan##index##_speed, S_IRUGO | S_IWUSR,        \
+                show_fan_speed, set_fan_speed, index);                  \
+static SENSOR_DEVICE_ATTR(fan##index##_fault, S_IRUGO,                  \
+                show_fan_fault, NULL, index)
+
+fan(0);
+fan(1);
+fan(2);
+fan(3);
+fan(4);
+
+static SENSOR_DEVICE_ATTR(psu_fan_fault, S_IRUGO, show_fan_fault, NULL, 6);
+
+static ssize_t show_temp(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        int temp_nr = to_sensor_dev_attr(attr)->index;
+        struct env *p = dev_get_drvdata(dev);
+        s8 val;
+
+        val = env_read(p, IREG_LCL_TEMP + temp_nr);
+        return sprintf(buf, "%d\n", ((int) val) - 64);
+}
+
+static SENSOR_DEVICE_ATTR(adt7462_local_temp, S_IRUGO, show_temp, NULL, 0);
+static SENSOR_DEVICE_ATTR(cpu0_temp, S_IRUGO, show_temp, NULL, 1);
+static SENSOR_DEVICE_ATTR(cpu1_temp, S_IRUGO, show_temp, NULL, 2);
+static SENSOR_DEVICE_ATTR(motherboard_temp, S_IRUGO, show_temp, NULL, 3);
+static SENSOR_DEVICE_ATTR(lm95221_local_temp, S_IRUGO, show_temp, NULL, 4);
+static SENSOR_DEVICE_ATTR(fire_temp, S_IRUGO, show_temp, NULL, 5);
+static SENSOR_DEVICE_ATTR(lsi1064_local_temp, S_IRUGO, show_temp, NULL, 6);
+static SENSOR_DEVICE_ATTR(front_panel_temp, S_IRUGO, show_temp, NULL, 7);
+static SENSOR_DEVICE_ATTR(psu_temp, S_IRUGO, show_temp, NULL, 13);
+
+static ssize_t show_stat_bit(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        int index = to_sensor_dev_attr(attr)->index;
+        struct env *p = dev_get_drvdata(dev);
+        u8 val;
+
+        val = readb(p->regs + REG_STAT);
+        return sprintf(buf, "%d\n", (val & (1 << index)) ? 1 : 0);
+}
+
+static SENSOR_DEVICE_ATTR(fan_failure, S_IRUGO, show_stat_bit, NULL, 0);
+static SENSOR_DEVICE_ATTR(env_bus_busy, S_IRUGO, show_stat_bit, NULL, 1);
+static SENSOR_DEVICE_ATTR(env_data_stale, S_IRUGO, show_stat_bit, NULL, 2);
+static SENSOR_DEVICE_ATTR(tpm_self_test_passed, S_IRUGO, show_stat_bit, NULL, 3);
+
+static ssize_t show_fwver(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct env *p = dev_get_drvdata(dev);
+        u8 val;
+
+        val = readb(p->regs + REG_STAT);
+        return sprintf(buf, "%d\n", val >> 4);
+}
+
+static SENSOR_DEVICE_ATTR(firmware_version, S_IRUGO, show_fwver, NULL, 0);
+
+static ssize_t show_name(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        return sprintf(buf, "ultra45\n");
+}
+
+static SENSOR_DEVICE_ATTR(name, S_IRUGO, show_name, NULL, 0);
+
+static struct attribute *env_attributes[] = {
+        &sensor_dev_attr_fan0_speed.dev_attr.attr,
+        &sensor_dev_attr_fan0_fault.dev_attr.attr,
+        &sensor_dev_attr_fan1_speed.dev_attr.attr,
+        &sensor_dev_attr_fan1_fault.dev_attr.attr,
+        &sensor_dev_attr_fan2_speed.dev_attr.attr,
+        &sensor_dev_attr_fan2_fault.dev_attr.attr,
+        &sensor_dev_attr_fan3_speed.dev_attr.attr,
+        &sensor_dev_attr_fan3_fault.dev_attr.attr,
+        &sensor_dev_attr_fan4_speed.dev_attr.attr,
+        &sensor_dev_attr_fan4_fault.dev_attr.attr,
+        &sensor_dev_attr_psu_fan_fault.dev_attr.attr,
+        &sensor_dev_attr_adt7462_local_temp.dev_attr.attr,
+        &sensor_dev_attr_cpu0_temp.dev_attr.attr,
+        &sensor_dev_attr_cpu1_temp.dev_attr.attr,
+        &sensor_dev_attr_motherboard_temp.dev_attr.attr,
+        &sensor_dev_attr_lm95221_local_temp.dev_attr.attr,
+        &sensor_dev_attr_fire_temp.dev_attr.attr,
+        &sensor_dev_attr_lsi1064_local_temp.dev_attr.attr,
+        &sensor_dev_attr_front_panel_temp.dev_attr.attr,
+        &sensor_dev_attr_psu_temp.dev_attr.attr,
+        &sensor_dev_attr_fan_failure.dev_attr.attr,
+        &sensor_dev_attr_env_bus_busy.dev_attr.attr,
+        &sensor_dev_attr_env_data_stale.dev_attr.attr,
+        &sensor_dev_attr_tpm_self_test_passed.dev_attr.attr,
+        &sensor_dev_attr_firmware_version.dev_attr.attr,
+        &sensor_dev_attr_name.dev_attr.attr,
+        NULL,
+};
+
+static const struct attribute_group env_group = {
+        .attrs = env_attributes,
+};
+
+static int __devinit env_probe(struct of_device *op,
+                               const struct of_device_id *match)
+{
+        struct env *p = kzalloc(sizeof(*p), GFP_KERNEL);
+        int err = -ENOMEM;
+
+        if (!p)
+                goto out;
+
+        spin_lock_init(&p->lock);
+
+        p->regs = of_ioremap(&op->resource[0], 0, REG_SIZE, "pic16f747");
+        if (!p->regs)
+                goto out_free;
+
+        err = sysfs_create_group(&op->dev.kobj, &env_group);
+        if (err)
+                goto out_iounmap;
+
+        p->hwmon_dev = hwmon_device_register(&op->dev);
+        if (IS_ERR(p->hwmon_dev)) {
+                err = PTR_ERR(p->hwmon_dev);
+                goto out_sysfs_remove_group;
+        }
+
+        dev_set_drvdata(&op->dev, p);
+        err = 0;
+
+out:
+        return err;
+
+out_sysfs_remove_group:
+        sysfs_remove_group(&op->dev.kobj, &env_group);
+
+out_iounmap:
+        of_iounmap(&op->resource[0], p->regs, REG_SIZE);
+
+out_free:
+        kfree(p);
+        goto out;
+}
+
+static int __devexit env_remove(struct of_device *op)
+{
+        struct env *p = dev_get_drvdata(&op->dev);
+
+        if (p) {
+                sysfs_remove_group(&op->dev.kobj, &env_group);
+                hwmon_device_unregister(p->hwmon_dev);
+                of_iounmap(&op->resource[0], p->regs, REG_SIZE);
+                kfree(p);
+        }
+
+        return 0;
+}
+
+static const struct of_device_id env_match[] = {
+        {
+                .name = "env-monitor",
+                .compatible = "SUNW,ebus-pic16f747-env",
+        },
+        {},
+};
+MODULE_DEVICE_TABLE(of, env_match);
+
+static struct of_platform_driver env_driver = {
+        .name           = "ultra45_env",
+        .match_table    = env_match,
+        .probe          = env_probe,
+        .remove         = __devexit_p(env_remove),
+};
+
+static int __init env_init(void)
+{
+        return of_register_driver(&env_driver, &of_bus_type);
+}
+
+static void __exit env_exit(void)
+{
+        of_unregister_driver(&env_driver);
+}
+
+module_init(env_init);
+module_exit(env_exit);
diff --git a/drivers/hwmon/w83627hf.c b/drivers/hwmon/w83627hf.c
index 9564fb069957..b30e5796cb26 100644
--- a/drivers/hwmon/w83627hf.c
+++ b/drivers/hwmon/w83627hf.c
@@ -67,10 +67,6 @@ module_param(force_i2c, byte, 0);
 MODULE_PARM_DESC(force_i2c,
                  "Initialize the i2c address of the sensors");
 
-static int reset;
-module_param(reset, bool, 0);
-MODULE_PARM_DESC(reset, "Set to one to reset chip on load");
-
 static int init = 1;
 module_param(init, bool, 0);
 MODULE_PARM_DESC(init, "Set to zero to bypass chip initialization");
@@ -209,6 +205,13 @@ static const u16 w83627hf_reg_temp_over[]	= { 0x39, 0x155, 0x255 };
 #define W83627HF_REG_PWM1 0x5A
 #define W83627HF_REG_PWM2 0x5B
 
+static const u8 W83627THF_REG_PWM_ENABLE[] = {
+        0x04,           /* FAN 1 mode */
+        0x04,           /* FAN 2 mode */
+        0x12,           /* FAN AUX mode */
+};
+static const u8 W83627THF_PWM_ENABLE_SHIFT[] = { 2, 4, 1 };
+
 #define W83627THF_REG_PWM1              0x01    /* 697HF/637HF/687THF too */
 #define W83627THF_REG_PWM2              0x03    /* 697HF/637HF/687THF too */
 #define W83627THF_REG_PWM3              0x11    /* 637HF/687THF too */
@@ -366,6 +369,9 @@ struct w83627hf_data {
         u32 alarms;             /* Register encoding, combined */
         u32 beep_mask;          /* Register encoding, combined */
         u8 pwm[3];              /* Register value */
+        u8 pwm_enable[3];       /* 1 = manual
+                                   2 = thermal cruise (also called SmartFan I)
+                                   3 = fan speed cruise */
         u8 pwm_freq[3];         /* Register value */
         u16 sens[3];            /* 1 = pentium diode; 2 = 3904 diode;
                                    4 = thermistor */
@@ -957,6 +963,42 @@ static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO|S_IWUSR, show_pwm, store_pwm, 1);
 static SENSOR_DEVICE_ATTR(pwm3, S_IRUGO|S_IWUSR, show_pwm, store_pwm, 2);
 
 static ssize_t
+show_pwm_enable(struct device *dev, struct device_attribute *devattr, char *buf)
+{
+        int nr = to_sensor_dev_attr(devattr)->index;
+        struct w83627hf_data *data = w83627hf_update_device(dev);
+        return sprintf(buf, "%d\n", data->pwm_enable[nr]);
+}
+
+static ssize_t
+store_pwm_enable(struct device *dev, struct device_attribute *devattr,
+          const char *buf, size_t count)
+{
+        int nr = to_sensor_dev_attr(devattr)->index;
+        struct w83627hf_data *data = dev_get_drvdata(dev);
+        unsigned long val = simple_strtoul(buf, NULL, 10);
+        u8 reg;
+
+        if (!val || (val > 3))  /* modes 1, 2 and 3 are supported */
+                return -EINVAL;
+        mutex_lock(&data->update_lock);
+        data->pwm_enable[nr] = val;
+        reg = w83627hf_read_value(data, W83627THF_REG_PWM_ENABLE[nr]);
+        reg &= ~(0x03 << W83627THF_PWM_ENABLE_SHIFT[nr]);
+        reg |= (val - 1) << W83627THF_PWM_ENABLE_SHIFT[nr];
+        w83627hf_write_value(data, W83627THF_REG_PWM_ENABLE[nr], reg);
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+
+static SENSOR_DEVICE_ATTR(pwm1_enable, S_IRUGO|S_IWUSR, show_pwm_enable,
+                                                  store_pwm_enable, 0);
+static SENSOR_DEVICE_ATTR(pwm2_enable, S_IRUGO|S_IWUSR, show_pwm_enable,
+                                                  store_pwm_enable, 1);
+static SENSOR_DEVICE_ATTR(pwm3_enable, S_IRUGO|S_IWUSR, show_pwm_enable,
+                                                  store_pwm_enable, 2);
+
+static ssize_t
 show_pwm_freq(struct device *dev, struct device_attribute *devattr, char *buf)
 {
         int nr = to_sensor_dev_attr(devattr)->index;
@@ -1223,6 +1265,11 @@ static struct attribute *w83627hf_attributes_opt[] = {
         &sensor_dev_attr_pwm1_freq.dev_attr.attr,
         &sensor_dev_attr_pwm2_freq.dev_attr.attr,
         &sensor_dev_attr_pwm3_freq.dev_attr.attr,
+
+        &sensor_dev_attr_pwm1_enable.dev_attr.attr,
+        &sensor_dev_attr_pwm2_enable.dev_attr.attr,
+        &sensor_dev_attr_pwm3_enable.dev_attr.attr,
+
         NULL
 };
 
@@ -1366,6 +1413,19 @@ static int __devinit w83627hf_probe(struct platform_device *pdev)
                                 &sensor_dev_attr_pwm3_freq.dev_attr)))
                         goto ERROR4;
 
+        if (data->type != w83627hf)
+                if ((err = device_create_file(dev,
+                                &sensor_dev_attr_pwm1_enable.dev_attr))
+                 || (err = device_create_file(dev,
+                                &sensor_dev_attr_pwm2_enable.dev_attr)))
+                        goto ERROR4;
+
+        if (data->type == w83627thf || data->type == w83637hf
+         || data->type == w83687thf)
+                if ((err = device_create_file(dev,
+                                &sensor_dev_attr_pwm3_enable.dev_attr)))
+                        goto ERROR4;
+
         data->hwmon_dev = hwmon_device_register(dev);
         if (IS_ERR(data->hwmon_dev)) {
                 err = PTR_ERR(data->hwmon_dev);
@@ -1536,29 +1596,6 @@ static void __devinit w83627hf_init_device(struct platform_device *pdev)
         enum chips type = data->type;
         u8 tmp;
 
-        if (reset) {
-                /* Resetting the chip has been the default for a long time,
-                   but repeatedly caused problems (fans going to full
-                   speed...) so it is now optional. It might even go away if
-                   nobody reports it as being useful, as I see very little
-                   reason why this would be needed at all. */
-                dev_info(&pdev->dev, "If reset=1 solved a problem you were "
-                         "having, please report!\n");
-
-                /* save this register */
-                i = w83627hf_read_value(data, W83781D_REG_BEEP_CONFIG);
-                /* Reset all except Watchdog values and last conversion values
-                   This sets fan-divs to 2, among others */
-                w83627hf_write_value(data, W83781D_REG_CONFIG, 0x80);
-                /* Restore the register and disable power-on abnormal beep.
-                   This saves FAN 1/2/3 input/output values set by BIOS. */
-                w83627hf_write_value(data, W83781D_REG_BEEP_CONFIG, i | 0x80);
-                /* Disable master beep-enable (reset turns it on).
-                   Individual beeps should be reset to off but for some reason
-                   disabling this bit helps some people not get beeped */
-                w83627hf_write_value(data, W83781D_REG_BEEP_INTS2, 0);
-        }
-
         /* Minimize conflicts with other winbond i2c-only clients...  */
         /* disable i2c subclients... how to disable main i2c client?? */
         /* force i2c address to relatively uncommon address */
@@ -1655,6 +1692,7 @@ static struct w83627hf_data *w83627hf_update_device(struct device *dev)
 {
         struct w83627hf_data *data = dev_get_drvdata(dev);
         int i, num_temps = (data->type == w83697hf) ? 2 : 3;
+        int num_pwms = (data->type == w83697hf) ? 2 : 3;
 
         mutex_lock(&data->update_lock);
 
@@ -1707,6 +1745,15 @@ static struct w83627hf_data *w83627hf_update_device(struct device *dev)
                                         break;
                         }
                 }
+                if (data->type != w83627hf) {
+                        for (i = 0; i < num_pwms; i++) {
+                                u8 tmp = w83627hf_read_value(data,
+                                        W83627THF_REG_PWM_ENABLE[i]);
+                                data->pwm_enable[i] =
+                                        ((tmp >> W83627THF_PWM_ENABLE_SHIFT[i])
+                                        & 0x03) + 1;
+                        }
+                }
                 for (i = 0; i < num_temps; i++) {
                         data->temp[i] = w83627hf_read_value(
                                                 data, w83627hf_reg_temp[i]);
diff --git a/drivers/hwmon/w83781d.c b/drivers/hwmon/w83781d.c
index f942ecdd47c8..fc12bd412e3a 100644
--- a/drivers/hwmon/w83781d.c
+++ b/drivers/hwmon/w83781d.c
@@ -4,7 +4,7 @@
     Copyright (c) 1998 - 2001  Frodo Looijaard <frodol@dds.nl>,
                                Philip Edelbrock <phil@netroedge.com>,
                                and Mark Studebaker <mdsxyz123@yahoo.com>
-    Copyright (c) 2007         Jean Delvare <khali@linux-fr.org>
+    Copyright (c) 2007 - 2008  Jean Delvare <khali@linux-fr.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
@@ -38,25 +38,24 @@
 #include <linux/slab.h>
 #include <linux/jiffies.h>
 #include <linux/i2c.h>
-#include <linux/platform_device.h>
-#include <linux/ioport.h>
 #include <linux/hwmon.h>
 #include <linux/hwmon-vid.h>
 #include <linux/hwmon-sysfs.h>
 #include <linux/sysfs.h>
 #include <linux/err.h>
 #include <linux/mutex.h>
+
+#ifdef CONFIG_ISA
+#include <linux/platform_device.h>
+#include <linux/ioport.h>
 #include <asm/io.h>
-#include "lm75.h"
+#endif
 
-/* ISA device, if found */
-static struct platform_device *pdev;
+#include "lm75.h"
 
 /* Addresses to scan */
 static const unsigned short normal_i2c[] = { 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,
                                                 0x2e, 0x2f, I2C_CLIENT_END };
-static unsigned short isa_address = 0x290;
-
 /* Insmod parameters */
 I2C_CLIENT_INSMOD_4(w83781d, w83782d, w83783s, as99127f);
 I2C_CLIENT_MODULE_PARM(force_subclients, "List of subclient addresses: "
@@ -178,9 +177,9 @@ FAN_FROM_REG(u8 val, int div)
 #define TEMP_FROM_REG(val)              ((val) * 1000)
 
 #define BEEP_MASK_FROM_REG(val,type)    ((type) == as99127f ? \
-                                         (val) ^ 0x7fff : (val))
+                                         (~(val)) & 0x7fff : (val) & 0xff7fff)
 #define BEEP_MASK_TO_REG(val,type)      ((type) == as99127f ? \
-                                         (~(val)) & 0x7fff : (val) & 0xffffff)
+                                         (~(val)) & 0x7fff : (val) & 0xff7fff)
 
 #define DIV_FROM_REG(val)               (1 << (val))
 
@@ -199,25 +198,16 @@ DIV_TO_REG(long val, enum chips type)
         return i;
 }
 
-/* There are some complications in a module like this. First off, W83781D chips
-   may be both present on the SMBus and the ISA bus, and we have to handle
-   those cases separately at some places. Second, there might be several
-   W83781D chips available (well, actually, that is probably never done; but
-   it is a clean illustration of how to handle a case like that). Finally,
-   a specific chip may be attached to *both* ISA and SMBus, and we would
-   not like to detect it double. Fortunately, in the case of the W83781D at
-   least, a register tells us what SMBus address we are on, so that helps
-   a bit - except if there could be more than one SMBus. Groan. No solution
-   for this yet. */
-
-/* For ISA chips, we abuse the i2c_client addr and name fields. We also use
-   the driver field to differentiate between I2C and ISA chips. */
 struct w83781d_data {
-        struct i2c_client client;
+        struct i2c_client *client;
         struct device *hwmon_dev;
         struct mutex lock;
         enum chips type;
 
+        /* For ISA device only */
+        const char *name;
+        int isa_addr;
+
         struct mutex update_lock;
         char valid;             /* !=0 if following fields are valid */
         unsigned long last_updated;     /* In jiffies */
@@ -240,7 +230,6 @@ struct w83781d_data {
         u8 vid;                 /* Register encoding, combined */
         u32 alarms;             /* Register encoding, combined */
         u32 beep_mask;          /* Register encoding, combined */
-        u8 beep_enable;         /* Boolean */
         u8 pwm[4];              /* Register value */
         u8 pwm2_enable;         /* Boolean */
         u16 sens[3];            /* 782D/783S only.
@@ -249,36 +238,14 @@ struct w83781d_data {
         u8 vrm;
 };
 
-static int w83781d_attach_adapter(struct i2c_adapter *adapter);
-static int w83781d_detect(struct i2c_adapter *adapter, int address, int kind);
-static int w83781d_detach_client(struct i2c_client *client);
-
-static int __devinit w83781d_isa_probe(struct platform_device *pdev);
-static int __devexit w83781d_isa_remove(struct platform_device *pdev);
+static struct w83781d_data *w83781d_data_if_isa(void);
+static int w83781d_alias_detect(struct i2c_client *client, u8 chipid);
 
 static int w83781d_read_value(struct w83781d_data *data, u16 reg);
 static int w83781d_write_value(struct w83781d_data *data, u16 reg, u16 value);
 static struct w83781d_data *w83781d_update_device(struct device *dev);
 static void w83781d_init_device(struct device *dev);
 
-static struct i2c_driver w83781d_driver = {
-        .driver = {
-                .name = "w83781d",
-        },
-        .attach_adapter = w83781d_attach_adapter,
-        .detach_client = w83781d_detach_client,
-};
-
-static struct platform_driver w83781d_isa_driver = {
-        .driver = {
-                .owner = THIS_MODULE,
-                .name = "w83781d",
-        },
-        .probe = w83781d_isa_probe,
-        .remove = w83781d_isa_remove,
-};
-
-
 /* following are the sysfs callback functions */
 #define show_in_reg(reg) \
 static ssize_t show_##reg (struct device *dev, struct device_attribute *da, \
@@ -513,11 +480,6 @@ static ssize_t show_beep_mask (struct device *dev, struct device_attribute *attr
         return sprintf(buf, "%ld\n",
                        (long)BEEP_MASK_FROM_REG(data->beep_mask, data->type));
 }
-static ssize_t show_beep_enable (struct device *dev, struct device_attribute *attr, char *buf)
-{
-        struct w83781d_data *data = w83781d_update_device(dev);
-        return sprintf(buf, "%ld\n", (long)data->beep_enable);
-}
 
 static ssize_t
 store_beep_mask(struct device *dev, struct device_attribute *attr,
@@ -529,12 +491,12 @@ store_beep_mask(struct device *dev, struct device_attribute *attr,
         val = simple_strtoul(buf, NULL, 10);
 
         mutex_lock(&data->update_lock);
-        data->beep_mask = BEEP_MASK_TO_REG(val, data->type);
+        data->beep_mask &= 0x8000; /* preserve beep enable */
+        data->beep_mask |= BEEP_MASK_TO_REG(val, data->type);
         w83781d_write_value(data, W83781D_REG_BEEP_INTS1,
                             data->beep_mask & 0xff);
         w83781d_write_value(data, W83781D_REG_BEEP_INTS2,
-                            ((data->beep_mask >> 8) & 0x7f)
-                            | data->beep_enable << 7);
+                            (data->beep_mask >> 8) & 0xff);
         if (data->type != w83781d && data->type != as99127f) {
                 w83781d_write_value(data, W83781D_REG_BEEP_INTS3,
                                     ((data->beep_mask) >> 16) & 0xff);
@@ -544,31 +506,8 @@ store_beep_mask(struct device *dev, struct device_attribute *attr,
         return count;
 }
 
-static ssize_t
-store_beep_enable(struct device *dev, struct device_attribute *attr,
-                const char *buf, size_t count)
-{
-        struct w83781d_data *data = dev_get_drvdata(dev);
-        u32 val;
-
-        val = simple_strtoul(buf, NULL, 10);
-        if (val != 0 && val != 1)
-                return -EINVAL;
-
-        mutex_lock(&data->update_lock);
-        data->beep_enable = val;
-        val = w83781d_read_value(data, W83781D_REG_BEEP_INTS2) & 0x7f;
-        val |= data->beep_enable << 7;
-        w83781d_write_value(data, W83781D_REG_BEEP_INTS2, val);
-        mutex_unlock(&data->update_lock);
-
-        return count;
-}
-
 static DEVICE_ATTR(beep_mask, S_IRUGO | S_IWUSR,
                 show_beep_mask, store_beep_mask);
-static DEVICE_ATTR(beep_enable, S_IRUGO | S_IWUSR,
-                show_beep_enable, store_beep_enable);
 
 static ssize_t show_beep(struct device *dev, struct device_attribute *attr,
                 char *buf)
@@ -663,6 +602,8 @@ static SENSOR_DEVICE_ATTR(temp2_beep, S_IRUGO | S_IWUSR,
                         show_beep, store_beep, 5);
 static SENSOR_DEVICE_ATTR(temp3_beep, S_IRUGO,
                         show_temp3_beep, store_beep, 13);
+static SENSOR_DEVICE_ATTR(beep_enable, S_IRUGO | S_IWUSR,
+                        show_beep, store_beep, 15);
 
 static ssize_t
 show_fan_div(struct device *dev, struct device_attribute *da, char *buf)
@@ -866,45 +807,19 @@ static SENSOR_DEVICE_ATTR(temp2_type, S_IRUGO | S_IWUSR,
 static SENSOR_DEVICE_ATTR(temp3_type, S_IRUGO | S_IWUSR,
         show_sensor, store_sensor, 2);
 
-/* I2C devices get this name attribute automatically, but for ISA devices
-   we must create it by ourselves. */
-static ssize_t
-show_name(struct device *dev, struct device_attribute *devattr, char *buf)
-{
-        struct w83781d_data *data = dev_get_drvdata(dev);
-        return sprintf(buf, "%s\n", data->client.name);
-}
-static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
-
-/* This function is called when:
-     * w83781d_driver is inserted (when this module is loaded), for each
-       available adapter
-     * when a new adapter is inserted (and w83781d_driver is still present) */
-static int
-w83781d_attach_adapter(struct i2c_adapter *adapter)
-{
-        if (!(adapter->class & I2C_CLASS_HWMON))
-                return 0;
-        return i2c_probe(adapter, &addr_data, w83781d_detect);
-}
-
 /* Assumes that adapter is of I2C, not ISA variety.
  * OTHERWISE DON'T CALL THIS
  */
 static int
-w83781d_detect_subclients(struct i2c_adapter *adapter, int address, int kind,
-                struct i2c_client *new_client)
+w83781d_detect_subclients(struct i2c_client *new_client)
 {
         int i, val1 = 0, id;
         int err;
-        const char *client_name = "";
+        int address = new_client->addr;
+        unsigned short sc_addr[2];
+        struct i2c_adapter *adapter = new_client->adapter;
         struct w83781d_data *data = i2c_get_clientdata(new_client);
-
-        data->lm75[0] = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
-        if (!(data->lm75[0])) {
-                err = -ENOMEM;
-                goto ERROR_SC_0;
-        }
+        enum chips kind = data->type;
 
         id = i2c_adapter_id(adapter);
 
@@ -922,55 +837,35 @@ w83781d_detect_subclients(struct i2c_adapter *adapter, int address, int kind,
                 w83781d_write_value(data, W83781D_REG_I2C_SUBADDR,
                                 (force_subclients[2] & 0x07) |
                                 ((force_subclients[3] & 0x07) << 4));
-                data->lm75[0]->addr = force_subclients[2];
+                sc_addr[0] = force_subclients[2];
         } else {
                 val1 = w83781d_read_value(data, W83781D_REG_I2C_SUBADDR);
-                data->lm75[0]->addr = 0x48 + (val1 & 0x07);
+                sc_addr[0] = 0x48 + (val1 & 0x07);
         }
 
         if (kind != w83783s) {
-                data->lm75[1] = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
-                if (!(data->lm75[1])) {
-                        err = -ENOMEM;
-                        goto ERROR_SC_1;
-                }
-
                 if (force_subclients[0] == id &&
                     force_subclients[1] == address) {
-                        data->lm75[1]->addr = force_subclients[3];
+                        sc_addr[1] = force_subclients[3];
                 } else {
-                        data->lm75[1]->addr = 0x48 + ((val1 >> 4) & 0x07);
+                        sc_addr[1] = 0x48 + ((val1 >> 4) & 0x07);
                 }
-                if (data->lm75[0]->addr == data->lm75[1]->addr) {
+                if (sc_addr[0] == sc_addr[1]) {
                         dev_err(&new_client->dev,
                                "Duplicate addresses 0x%x for subclients.\n",
-                               data->lm75[0]->addr);
+                               sc_addr[0]);
                         err = -EBUSY;
                         goto ERROR_SC_2;
                 }
         }
 
-        if (kind == w83781d)
-                client_name = "w83781d subclient";
-        else if (kind == w83782d)
-                client_name = "w83782d subclient";
-        else if (kind == w83783s)
-                client_name = "w83783s subclient";
-        else if (kind == as99127f)
-                client_name = "as99127f subclient";
-
         for (i = 0; i <= 1; i++) {
-                /* store all data in w83781d */
-                i2c_set_clientdata(data->lm75[i], NULL);
-                data->lm75[i]->adapter = adapter;
-                data->lm75[i]->driver = &w83781d_driver;
-                data->lm75[i]->flags = 0;
-                strlcpy(data->lm75[i]->name, client_name,
-                        I2C_NAME_SIZE);
-                if ((err = i2c_attach_client(data->lm75[i]))) {
+                data->lm75[i] = i2c_new_dummy(adapter, sc_addr[i]);
+                if (!data->lm75[i]) {
                         dev_err(&new_client->dev, "Subclient %d "
                                 "registration at address 0x%x "
-                                "failed.\n", i, data->lm75[i]->addr);
+                                "failed.\n", i, sc_addr[i]);
+                        err = -ENOMEM;
                         if (i == 1)
                                 goto ERROR_SC_3;
                         goto ERROR_SC_2;
@@ -983,12 +878,9 @@ w83781d_detect_subclients(struct i2c_adapter *adapter, int address, int kind,
 
 /* Undo inits in case of errors */
 ERROR_SC_3:
-        i2c_detach_client(data->lm75[0]);
+        i2c_unregister_device(data->lm75[0]);
 ERROR_SC_2:
-        kfree(data->lm75[1]);
 ERROR_SC_1:
-        kfree(data->lm75[0]);
-ERROR_SC_0:
         return err;
 }
 
@@ -1029,7 +921,7 @@ static struct attribute* w83781d_attributes[] = {
         &dev_attr_vrm.attr,
         &dev_attr_alarms.attr,
         &dev_attr_beep_mask.attr,
-        &dev_attr_beep_enable.attr,
+        &sensor_dev_attr_beep_enable.dev_attr.attr,
         NULL
 };
 static const struct attribute_group w83781d_group = {
@@ -1151,96 +1043,74 @@ w83781d_create_files(struct device *dev, int kind, int is_isa)
                 }
         }
 
-        if (is_isa) {
-                err = device_create_file(&pdev->dev, &dev_attr_name);
-                if (err)
-                        return err;
-        }
-
         return 0;
 }
 
+/* Return 0 if detection is successful, -ENODEV otherwise */
 static int
-w83781d_detect(struct i2c_adapter *adapter, int address, int kind)
+w83781d_detect(struct i2c_client *client, int kind,
+               struct i2c_board_info *info)
 {
         int val1 = 0, val2;
-        struct i2c_client *client;
-        struct device *dev;
-        struct w83781d_data *data;
-        int err;
+        struct w83781d_data *isa = w83781d_data_if_isa();
+        struct i2c_adapter *adapter = client->adapter;
+        int address = client->addr;
         const char *client_name = "";
         enum vendor { winbond, asus } vendid;
 
-        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
-                err = -EINVAL;
-                goto ERROR1;
-        }
-
-        /* OK. For now, 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 access w83781d_{read,write}_value. */
-
-        if (!(data = kzalloc(sizeof(struct w83781d_data), GFP_KERNEL))) {
-                err = -ENOMEM;
-                goto ERROR1;
-        }
-
-        client = &data->client;
-        i2c_set_clientdata(client, data);
-        client->addr = address;
-        mutex_init(&data->lock);
-        client->adapter = adapter;
-        client->driver = &w83781d_driver;
-        dev = &client->dev;
+        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
+                return -ENODEV;
 
-        /* Now, we do the remaining detection. */
+        /* We block updates of the ISA device to minimize the risk of
+           concurrent access to the same W83781D chip through different
+           interfaces. */
+        if (isa)
+                mutex_lock(&isa->update_lock);
 
         /* The w8378?d may be stuck in some other bank than bank 0. This may
            make reading other information impossible. Specify a force=... or
            force_*=... parameter, and the Winbond will be reset to the right
            bank. */
         if (kind < 0) {
-                if (w83781d_read_value(data, W83781D_REG_CONFIG) & 0x80) {
+                if (i2c_smbus_read_byte_data
+                    (client, W83781D_REG_CONFIG) & 0x80) {
                         dev_dbg(&adapter->dev, "Detection of w83781d chip "
                                 "failed at step 3\n");
-                        err = -ENODEV;
-                        goto ERROR2;
+                        goto err_nodev;
                 }
-                val1 = w83781d_read_value(data, W83781D_REG_BANK);
-                val2 = w83781d_read_value(data, W83781D_REG_CHIPMAN);
+                val1 = i2c_smbus_read_byte_data(client, W83781D_REG_BANK);
+                val2 = i2c_smbus_read_byte_data(client, W83781D_REG_CHIPMAN);
                 /* Check for Winbond or Asus ID if in bank 0 */
                 if ((!(val1 & 0x07)) &&
                     (((!(val1 & 0x80)) && (val2 != 0xa3) && (val2 != 0xc3))
                      || ((val1 & 0x80) && (val2 != 0x5c) && (val2 != 0x12)))) {
                         dev_dbg(&adapter->dev, "Detection of w83781d chip "
                                 "failed at step 4\n");
-                        err = -ENODEV;
-                        goto ERROR2;
+                        goto err_nodev;
                 }
                 /* If Winbond SMBus, check address at 0x48.
                    Asus doesn't support, except for as99127f rev.2 */
                 if ((!(val1 & 0x80) && (val2 == 0xa3)) ||
                     ((val1 & 0x80) && (val2 == 0x5c))) {
-                        if (w83781d_read_value
-                            (data, W83781D_REG_I2C_ADDR) != address) {
+                        if (i2c_smbus_read_byte_data
+                            (client, W83781D_REG_I2C_ADDR) != address) {
                                 dev_dbg(&adapter->dev, "Detection of w83781d "
                                         "chip failed at step 5\n");
-                                err = -ENODEV;
-                                goto ERROR2;
+                                goto err_nodev;
                         }
                 }
         }
 
         /* We have either had a force parameter, or we have already detected the
            Winbond. Put it now into bank 0 and Vendor ID High Byte */
-        w83781d_write_value(data, W83781D_REG_BANK,
-                            (w83781d_read_value(data, W83781D_REG_BANK)
-                             & 0x78) | 0x80);
+        i2c_smbus_write_byte_data(client, W83781D_REG_BANK,
+                (i2c_smbus_read_byte_data(client, W83781D_REG_BANK)
+                 & 0x78) | 0x80);
 
         /* Determine the chip type. */
         if (kind <= 0) {
                 /* get vendor ID */
-                val2 = w83781d_read_value(data, W83781D_REG_CHIPMAN);
+                val2 = i2c_smbus_read_byte_data(client, W83781D_REG_CHIPMAN);
                 if (val2 == 0x5c)
                         vendid = winbond;
                 else if (val2 == 0x12)
@@ -1248,11 +1118,10 @@ w83781d_detect(struct i2c_adapter *adapter, int address, int kind)
                 else {
                         dev_dbg(&adapter->dev, "w83781d chip vendor is "
                                 "neither Winbond nor Asus\n");
-                        err = -ENODEV;
-                        goto ERROR2;
+                        goto err_nodev;
                 }
 
-                val1 = w83781d_read_value(data, W83781D_REG_WCHIPID);
+                val1 = i2c_smbus_read_byte_data(client, W83781D_REG_WCHIPID);
                 if ((val1 == 0x10 || val1 == 0x11) && vendid == winbond)
                         kind = w83781d;
                 else if (val1 == 0x30 && vendid == winbond)
@@ -1266,11 +1135,20 @@ w83781d_detect(struct i2c_adapter *adapter, int address, int kind)
                                 dev_warn(&adapter->dev, "Ignoring 'force' "
                                          "parameter for unknown chip at "
                                          "address 0x%02x\n", address);
-                        err = -EINVAL;
-                        goto ERROR2;
+                        goto err_nodev;
+                }
+
+                if ((kind == w83781d || kind == w83782d)
+                 && w83781d_alias_detect(client, val1)) {
+                        dev_dbg(&adapter->dev, "Device at 0x%02x appears to "
+                                "be the same as ISA device\n", address);
+                        goto err_nodev;
                 }
         }
 
+        if (isa)
+                mutex_unlock(&isa->update_lock);
+
         if (kind == w83781d) {
                 client_name = "w83781d";
         } else if (kind == w83782d) {
@@ -1281,24 +1159,46 @@ w83781d_detect(struct i2c_adapter *adapter, int address, int kind)
                 client_name = "as99127f";
         }
 
-        /* Fill in the remaining client fields and put into the global list */
-        strlcpy(client->name, client_name, I2C_NAME_SIZE);
-        data->type = kind;
+        strlcpy(info->type, client_name, I2C_NAME_SIZE);
+
+        return 0;
+
+ err_nodev:
+        if (isa)
+                mutex_unlock(&isa->update_lock);
+        return -ENODEV;
+}
+
+static int
+w83781d_probe(struct i2c_client *client, const struct i2c_device_id *id)
+{
+        struct device *dev = &client->dev;
+        struct w83781d_data *data;
+        int err;
+
+        data = kzalloc(sizeof(struct w83781d_data), GFP_KERNEL);
+        if (!data) {
+                err = -ENOMEM;
+                goto ERROR1;
+        }
+
+        i2c_set_clientdata(client, data);
+        mutex_init(&data->lock);
+        mutex_init(&data->update_lock);
 
-        /* Tell the I2C layer a new client has arrived */
-        if ((err = i2c_attach_client(client)))
-                goto ERROR2;
+        data->type = id->driver_data;
+        data->client = client;
 
         /* attach secondary i2c lm75-like clients */
-        if ((err = w83781d_detect_subclients(adapter, address,
-                        kind, client)))
+        err = w83781d_detect_subclients(client);
+        if (err)
                 goto ERROR3;
 
         /* Initialize the chip */
         w83781d_init_device(dev);
 
         /* Register sysfs hooks */
-        err = w83781d_create_files(dev, kind, 0);
+        err = w83781d_create_files(dev, data->type, 0);
         if (err)
                 goto ERROR4;
 
@@ -1314,264 +1214,113 @@ ERROR4:
         sysfs_remove_group(&dev->kobj, &w83781d_group);
         sysfs_remove_group(&dev->kobj, &w83781d_group_opt);
 
-        if (data->lm75[1]) {
-                i2c_detach_client(data->lm75[1]);
-                kfree(data->lm75[1]);
-        }
-        if (data->lm75[0]) {
-                i2c_detach_client(data->lm75[0]);
-                kfree(data->lm75[0]);
-        }
+        if (data->lm75[0])
+                i2c_unregister_device(data->lm75[0]);
+        if (data->lm75[1])
+                i2c_unregister_device(data->lm75[1]);
 ERROR3:
-        i2c_detach_client(client);
-ERROR2:
+        i2c_set_clientdata(client, NULL);
         kfree(data);
 ERROR1:
         return err;
 }
 
 static int
-w83781d_detach_client(struct i2c_client *client)
+w83781d_remove(struct i2c_client *client)
 {
         struct w83781d_data *data = i2c_get_clientdata(client);
-        int err;
-
-        /* main client */
-        if (data) {
-                hwmon_device_unregister(data->hwmon_dev);
-                sysfs_remove_group(&client->dev.kobj, &w83781d_group);
-                sysfs_remove_group(&client->dev.kobj, &w83781d_group_opt);
-        }
-
-        if ((err = i2c_detach_client(client)))
-                return err;
+        struct device *dev = &client->dev;
 
-        /* main client */
-        if (data)
-                kfree(data);
-
-        /* subclient */
-        else
-                kfree(client);
-
-        return 0;
-}
-
-static int __devinit
-w83781d_isa_probe(struct platform_device *pdev)
-{
-        int err, reg;
-        struct w83781d_data *data;
-        struct resource *res;
-        const char *name;
-
-        /* Reserve the ISA region */
-        res = platform_get_resource(pdev, IORESOURCE_IO, 0);
-        if (!request_region(res->start + W83781D_ADDR_REG_OFFSET, 2,
-                            "w83781d")) {
-                err = -EBUSY;
-                goto exit;
-        }
-
-        if (!(data = kzalloc(sizeof(struct w83781d_data), GFP_KERNEL))) {
-                err = -ENOMEM;
-                goto exit_release_region;
-        }
-        mutex_init(&data->lock);
-        data->client.addr = res->start;
-        i2c_set_clientdata(&data->client, data);
-        platform_set_drvdata(pdev, data);
-
-        reg = w83781d_read_value(data, W83781D_REG_WCHIPID);
-        switch (reg) {
-        case 0x30:
-                data->type = w83782d;
-                name = "w83782d";
-                break;
-        default:
-                data->type = w83781d;
-                name = "w83781d";
-        }
-        strlcpy(data->client.name, name, I2C_NAME_SIZE);
-
-        /* Initialize the W83781D chip */
-        w83781d_init_device(&pdev->dev);
-
-        /* Register sysfs hooks */
-        err = w83781d_create_files(&pdev->dev, data->type, 1);
-        if (err)
-                goto exit_remove_files;
-
-        data->hwmon_dev = hwmon_device_register(&pdev->dev);
-        if (IS_ERR(data->hwmon_dev)) {
-                err = PTR_ERR(data->hwmon_dev);
-                goto exit_remove_files;
-        }
-
-        return 0;
+        hwmon_device_unregister(data->hwmon_dev);
 
- exit_remove_files:
-        sysfs_remove_group(&pdev->dev.kobj, &w83781d_group);
-        sysfs_remove_group(&pdev->dev.kobj, &w83781d_group_opt);
-        device_remove_file(&pdev->dev, &dev_attr_name);
-        kfree(data);
- exit_release_region:
-        release_region(res->start + W83781D_ADDR_REG_OFFSET, 2);
- exit:
-        return err;
-}
+        sysfs_remove_group(&dev->kobj, &w83781d_group);
+        sysfs_remove_group(&dev->kobj, &w83781d_group_opt);
 
-static int __devexit
-w83781d_isa_remove(struct platform_device *pdev)
-{
-        struct w83781d_data *data = platform_get_drvdata(pdev);
+        if (data->lm75[0])
+                i2c_unregister_device(data->lm75[0]);
+        if (data->lm75[1])
+                i2c_unregister_device(data->lm75[1]);
 
-        hwmon_device_unregister(data->hwmon_dev);
-        sysfs_remove_group(&pdev->dev.kobj, &w83781d_group);
-        sysfs_remove_group(&pdev->dev.kobj, &w83781d_group_opt);
-        device_remove_file(&pdev->dev, &dev_attr_name);
-        release_region(data->client.addr + W83781D_ADDR_REG_OFFSET, 2);
+        i2c_set_clientdata(client, NULL);
         kfree(data);
 
         return 0;
 }
 
-/* The SMBus locks itself, usually, but nothing may access the Winbond between
-   bank switches. ISA access must always be locked explicitly!
-   We ignore the W83781D BUSY flag at this moment - it could lead to deadlocks,
-   would slow down the W83781D access and should not be necessary.
-   There are some ugly typecasts here, but the good news is - they should
-   nowhere else be necessary! */
 static int
-w83781d_read_value(struct w83781d_data *data, u16 reg)
+w83781d_read_value_i2c(struct w83781d_data *data, u16 reg)
 {
-        struct i2c_client *client = &data->client;
-        int res, word_sized, bank;
+        struct i2c_client *client = data->client;
+        int res, bank;
         struct i2c_client *cl;
 
-        mutex_lock(&data->lock);
-        if (!client->driver) { /* ISA device */
-                word_sized = (((reg & 0xff00) == 0x100)
-                              || ((reg & 0xff00) == 0x200))
-                    && (((reg & 0x00ff) == 0x50)
-                        || ((reg & 0x00ff) == 0x53)
-                        || ((reg & 0x00ff) == 0x55));
-                if (reg & 0xff00) {
-                        outb_p(W83781D_REG_BANK,
-                               client->addr + W83781D_ADDR_REG_OFFSET);
-                        outb_p(reg >> 8,
-                               client->addr + W83781D_DATA_REG_OFFSET);
-                }
-                outb_p(reg & 0xff, client->addr + W83781D_ADDR_REG_OFFSET);
-                res = inb_p(client->addr + W83781D_DATA_REG_OFFSET);
-                if (word_sized) {
-                        outb_p((reg & 0xff) + 1,
-                               client->addr + W83781D_ADDR_REG_OFFSET);
-                        res =
-                            (res << 8) + inb_p(client->addr +
-                                               W83781D_DATA_REG_OFFSET);
-                }
-                if (reg & 0xff00) {
-                        outb_p(W83781D_REG_BANK,
-                               client->addr + W83781D_ADDR_REG_OFFSET);
-                        outb_p(0, client->addr + W83781D_DATA_REG_OFFSET);
-                }
+        bank = (reg >> 8) & 0x0f;
+        if (bank > 2)
+                /* switch banks */
+                i2c_smbus_write_byte_data(client, W83781D_REG_BANK,
+                                          bank);
+        if (bank == 0 || bank > 2) {
+                res = i2c_smbus_read_byte_data(client, reg & 0xff);
         } else {
-                bank = (reg >> 8) & 0x0f;
-                if (bank > 2)
-                        /* switch banks */
-                        i2c_smbus_write_byte_data(client, W83781D_REG_BANK,
-                                                  bank);
-                if (bank == 0 || bank > 2) {
-                        res = i2c_smbus_read_byte_data(client, reg & 0xff);
-                } else {
-                        /* switch to subclient */
-                        cl = data->lm75[bank - 1];
-                        /* convert from ISA to LM75 I2C addresses */
-                        switch (reg & 0xff) {
-                        case 0x50:      /* TEMP */
-                                res = swab16(i2c_smbus_read_word_data(cl, 0));
-                                break;
-                        case 0x52:      /* CONFIG */
-                                res = i2c_smbus_read_byte_data(cl, 1);
-                                break;
-                        case 0x53:      /* HYST */
-                                res = swab16(i2c_smbus_read_word_data(cl, 2));
-                                break;
-                        case 0x55:      /* OVER */
-                        default:
-                                res = swab16(i2c_smbus_read_word_data(cl, 3));
-                                break;
-                        }
+                /* switch to subclient */
+                cl = data->lm75[bank - 1];
+                /* convert from ISA to LM75 I2C addresses */
+                switch (reg & 0xff) {
+                case 0x50:      /* TEMP */
+                        res = swab16(i2c_smbus_read_word_data(cl, 0));
+                        break;
+                case 0x52:      /* CONFIG */
+                        res = i2c_smbus_read_byte_data(cl, 1);
+                        break;
+                case 0x53:      /* HYST */
+                        res = swab16(i2c_smbus_read_word_data(cl, 2));
+                        break;
+                case 0x55:      /* OVER */
+                default:
+                        res = swab16(i2c_smbus_read_word_data(cl, 3));
+                        break;
                 }
-                if (bank > 2)
-                        i2c_smbus_write_byte_data(client, W83781D_REG_BANK, 0);
         }
-        mutex_unlock(&data->lock);
+        if (bank > 2)
+                i2c_smbus_write_byte_data(client, W83781D_REG_BANK, 0);
+
         return res;
 }
 
 static int
-w83781d_write_value(struct w83781d_data *data, u16 reg, u16 value)
+w83781d_write_value_i2c(struct w83781d_data *data, u16 reg, u16 value)
 {
-        struct i2c_client *client = &data->client;
-        int word_sized, bank;
+        struct i2c_client *client = data->client;
+        int bank;
         struct i2c_client *cl;
 
-        mutex_lock(&data->lock);
-        if (!client->driver) { /* ISA device */
-                word_sized = (((reg & 0xff00) == 0x100)
-                              || ((reg & 0xff00) == 0x200))
-                    && (((reg & 0x00ff) == 0x53)
-                        || ((reg & 0x00ff) == 0x55));
-                if (reg & 0xff00) {
-                        outb_p(W83781D_REG_BANK,
-                               client->addr + W83781D_ADDR_REG_OFFSET);
-                        outb_p(reg >> 8,
-                               client->addr + W83781D_DATA_REG_OFFSET);
-                }
-                outb_p(reg & 0xff, client->addr + W83781D_ADDR_REG_OFFSET);
-                if (word_sized) {
-                        outb_p(value >> 8,
-                               client->addr + W83781D_DATA_REG_OFFSET);
-                        outb_p((reg & 0xff) + 1,
-                               client->addr + W83781D_ADDR_REG_OFFSET);
-                }
-                outb_p(value & 0xff, client->addr + W83781D_DATA_REG_OFFSET);
-                if (reg & 0xff00) {
-                        outb_p(W83781D_REG_BANK,
-                               client->addr + W83781D_ADDR_REG_OFFSET);
-                        outb_p(0, client->addr + W83781D_DATA_REG_OFFSET);
-                }
+        bank = (reg >> 8) & 0x0f;
+        if (bank > 2)
+                /* switch banks */
+                i2c_smbus_write_byte_data(client, W83781D_REG_BANK,
+                                          bank);
+        if (bank == 0 || bank > 2) {
+                i2c_smbus_write_byte_data(client, reg & 0xff,
+                                          value & 0xff);
         } else {
-                bank = (reg >> 8) & 0x0f;
-                if (bank > 2)
-                        /* switch banks */
-                        i2c_smbus_write_byte_data(client, W83781D_REG_BANK,
-                                                  bank);
-                if (bank == 0 || bank > 2) {
-                        i2c_smbus_write_byte_data(client, reg & 0xff,
-                                                  value & 0xff);
-                } else {
-                        /* switch to subclient */
-                        cl = data->lm75[bank - 1];
-                        /* convert from ISA to LM75 I2C addresses */
-                        switch (reg & 0xff) {
-                        case 0x52:      /* CONFIG */
-                                i2c_smbus_write_byte_data(cl, 1, value & 0xff);
-                                break;
-                        case 0x53:      /* HYST */
-                                i2c_smbus_write_word_data(cl, 2, swab16(value));
-                                break;
-                        case 0x55:      /* OVER */
-                                i2c_smbus_write_word_data(cl, 3, swab16(value));
-                                break;
-                        }
+                /* switch to subclient */
+                cl = data->lm75[bank - 1];
+                /* convert from ISA to LM75 I2C addresses */
+                switch (reg & 0xff) {
+                case 0x52:      /* CONFIG */
+                        i2c_smbus_write_byte_data(cl, 1, value & 0xff);
+                        break;
+                case 0x53:      /* HYST */
+                        i2c_smbus_write_word_data(cl, 2, swab16(value));
+                        break;
+                case 0x55:      /* OVER */
+                        i2c_smbus_write_word_data(cl, 3, swab16(value));
+                        break;
                 }
-                if (bank > 2)
-                        i2c_smbus_write_byte_data(client, W83781D_REG_BANK, 0);
         }
-        mutex_unlock(&data->lock);
+        if (bank > 2)
+                i2c_smbus_write_byte_data(client, W83781D_REG_BANK, 0);
+
         return 0;
 }
 
@@ -1678,7 +1427,7 @@ w83781d_init_device(struct device *dev)
 static struct w83781d_data *w83781d_update_device(struct device *dev)
 {
         struct w83781d_data *data = dev_get_drvdata(dev);
-        struct i2c_client *client = &data->client;
+        struct i2c_client *client = data->client;
         int i;
 
         mutex_lock(&data->update_lock);
@@ -1775,8 +1524,7 @@ static struct w83781d_data *w83781d_update_device(struct device *dev)
                                                 W83781D_REG_ALARM2) << 8);
                 }
                 i = w83781d_read_value(data, W83781D_REG_BEEP_INTS2);
-                data->beep_enable = i >> 7;
-                data->beep_mask = ((i & 0x7f) << 8) +
+                data->beep_mask = (i << 8) +
                     w83781d_read_value(data, W83781D_REG_BEEP_INTS1);
                 if ((data->type != w83781d) && (data->type != as99127f)) {
                         data->beep_mask |=
@@ -1792,6 +1540,275 @@ static struct w83781d_data *w83781d_update_device(struct device *dev)
         return data;
 }
 
+static const struct i2c_device_id w83781d_ids[] = {
+        { "w83781d", w83781d, },
+        { "w83782d", w83782d, },
+        { "w83783s", w83783s, },
+        { "as99127f", as99127f },
+        { /* LIST END */ }
+};
+MODULE_DEVICE_TABLE(i2c, w83781d_ids);
+
+static struct i2c_driver w83781d_driver = {
+        .class          = I2C_CLASS_HWMON,
+        .driver = {
+                .name = "w83781d",
+        },
+        .probe          = w83781d_probe,
+        .remove         = w83781d_remove,
+        .id_table       = w83781d_ids,
+        .detect         = w83781d_detect,
+        .address_data   = &addr_data,
+};
+
+/*
+ * ISA related code
+ */
+#ifdef CONFIG_ISA
+
+/* ISA device, if found */
+static struct platform_device *pdev;
+
+static unsigned short isa_address = 0x290;
+
+/* I2C devices get this name attribute automatically, but for ISA devices
+   we must create it by ourselves. */
+static ssize_t
+show_name(struct device *dev, struct device_attribute *devattr, char *buf)
+{
+        struct w83781d_data *data = dev_get_drvdata(dev);
+        return sprintf(buf, "%s\n", data->name);
+}
+static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
+
+static struct w83781d_data *w83781d_data_if_isa(void)
+{
+        return pdev ? platform_get_drvdata(pdev) : NULL;
+}
+
+/* Returns 1 if the I2C chip appears to be an alias of the ISA chip */
+static int w83781d_alias_detect(struct i2c_client *client, u8 chipid)
+{
+        struct w83781d_data *isa;
+        int i;
+
+        if (!pdev)      /* No ISA chip */
+                return 0;
+
+        isa = platform_get_drvdata(pdev);
+
+        if (w83781d_read_value(isa, W83781D_REG_I2C_ADDR) != client->addr)
+                return 0;       /* Address doesn't match */
+        if (w83781d_read_value(isa, W83781D_REG_WCHIPID) != chipid)
+                return 0;       /* Chip type doesn't match */
+
+        /* We compare all the limit registers, the config register and the
+         * interrupt mask registers */
+        for (i = 0x2b; i <= 0x3d; i++) {
+                if (w83781d_read_value(isa, i) !=
+                    i2c_smbus_read_byte_data(client, i))
+                        return 0;
+        }
+        if (w83781d_read_value(isa, W83781D_REG_CONFIG) !=
+            i2c_smbus_read_byte_data(client, W83781D_REG_CONFIG))
+                return 0;
+        for (i = 0x43; i <= 0x46; i++) {
+                if (w83781d_read_value(isa, i) !=
+                    i2c_smbus_read_byte_data(client, i))
+                        return 0;
+        }
+
+        return 1;
+}
+
+static int
+w83781d_read_value_isa(struct w83781d_data *data, u16 reg)
+{
+        int word_sized, res;
+
+        word_sized = (((reg & 0xff00) == 0x100)
+                      || ((reg & 0xff00) == 0x200))
+            && (((reg & 0x00ff) == 0x50)
+                || ((reg & 0x00ff) == 0x53)
+                || ((reg & 0x00ff) == 0x55));
+        if (reg & 0xff00) {
+                outb_p(W83781D_REG_BANK,
+                       data->isa_addr + W83781D_ADDR_REG_OFFSET);
+                outb_p(reg >> 8,
+                       data->isa_addr + W83781D_DATA_REG_OFFSET);
+        }
+        outb_p(reg & 0xff, data->isa_addr + W83781D_ADDR_REG_OFFSET);
+        res = inb_p(data->isa_addr + W83781D_DATA_REG_OFFSET);
+        if (word_sized) {
+                outb_p((reg & 0xff) + 1,
+                       data->isa_addr + W83781D_ADDR_REG_OFFSET);
+                res =
+                    (res << 8) + inb_p(data->isa_addr +
+                                       W83781D_DATA_REG_OFFSET);
+        }
+        if (reg & 0xff00) {
+                outb_p(W83781D_REG_BANK,
+                       data->isa_addr + W83781D_ADDR_REG_OFFSET);
+                outb_p(0, data->isa_addr + W83781D_DATA_REG_OFFSET);
+        }
+        return res;
+}
+
+static void
+w83781d_write_value_isa(struct w83781d_data *data, u16 reg, u16 value)
+{
+        int word_sized;
+
+        word_sized = (((reg & 0xff00) == 0x100)
+                      || ((reg & 0xff00) == 0x200))
+            && (((reg & 0x00ff) == 0x53)
+                || ((reg & 0x00ff) == 0x55));
+        if (reg & 0xff00) {
+                outb_p(W83781D_REG_BANK,
+                       data->isa_addr + W83781D_ADDR_REG_OFFSET);
+                outb_p(reg >> 8,
+                       data->isa_addr + W83781D_DATA_REG_OFFSET);
+        }
+        outb_p(reg & 0xff, data->isa_addr + W83781D_ADDR_REG_OFFSET);
+        if (word_sized) {
+                outb_p(value >> 8,
+                       data->isa_addr + W83781D_DATA_REG_OFFSET);
+                outb_p((reg & 0xff) + 1,
+                       data->isa_addr + W83781D_ADDR_REG_OFFSET);
+        }
+        outb_p(value & 0xff, data->isa_addr + W83781D_DATA_REG_OFFSET);
+        if (reg & 0xff00) {
+                outb_p(W83781D_REG_BANK,
+                       data->isa_addr + W83781D_ADDR_REG_OFFSET);
+                outb_p(0, data->isa_addr + W83781D_DATA_REG_OFFSET);
+        }
+}
+
+/* The SMBus locks itself, usually, but nothing may access the Winbond between
+   bank switches. ISA access must always be locked explicitly!
+   We ignore the W83781D BUSY flag at this moment - it could lead to deadlocks,
+   would slow down the W83781D access and should not be necessary.
+   There are some ugly typecasts here, but the good news is - they should
+   nowhere else be necessary! */
+static int
+w83781d_read_value(struct w83781d_data *data, u16 reg)
+{
+        struct i2c_client *client = data->client;
+        int res;
+
+        mutex_lock(&data->lock);
+        if (client)
+                res = w83781d_read_value_i2c(data, reg);
+        else
+                res = w83781d_read_value_isa(data, reg);
+        mutex_unlock(&data->lock);
+        return res;
+}
+
+static int
+w83781d_write_value(struct w83781d_data *data, u16 reg, u16 value)
+{
+        struct i2c_client *client = data->client;
+
+        mutex_lock(&data->lock);
+        if (client)
+                w83781d_write_value_i2c(data, reg, value);
+        else
+                w83781d_write_value_isa(data, reg, value);
+        mutex_unlock(&data->lock);
+        return 0;
+}
+
+static int __devinit
+w83781d_isa_probe(struct platform_device *pdev)
+{
+        int err, reg;
+        struct w83781d_data *data;
+        struct resource *res;
+
+        /* Reserve the ISA region */
+        res = platform_get_resource(pdev, IORESOURCE_IO, 0);
+        if (!request_region(res->start + W83781D_ADDR_REG_OFFSET, 2,
+                            "w83781d")) {
+                err = -EBUSY;
+                goto exit;
+        }
+
+        data = kzalloc(sizeof(struct w83781d_data), GFP_KERNEL);
+        if (!data) {
+                err = -ENOMEM;
+                goto exit_release_region;
+        }
+        mutex_init(&data->lock);
+        data->isa_addr = res->start;
+        platform_set_drvdata(pdev, data);
+
+        reg = w83781d_read_value(data, W83781D_REG_WCHIPID);
+        switch (reg) {
+        case 0x30:
+                data->type = w83782d;
+                data->name = "w83782d";
+                break;
+        default:
+                data->type = w83781d;
+                data->name = "w83781d";
+        }
+
+        /* Initialize the W83781D chip */
+        w83781d_init_device(&pdev->dev);
+
+        /* Register sysfs hooks */
+        err = w83781d_create_files(&pdev->dev, data->type, 1);
+        if (err)
+                goto exit_remove_files;
+
+        err = device_create_file(&pdev->dev, &dev_attr_name);
+        if (err)
+                goto exit_remove_files;
+
+        data->hwmon_dev = hwmon_device_register(&pdev->dev);
+        if (IS_ERR(data->hwmon_dev)) {
+                err = PTR_ERR(data->hwmon_dev);
+                goto exit_remove_files;
+        }
+
+        return 0;
+
+ exit_remove_files:
+        sysfs_remove_group(&pdev->dev.kobj, &w83781d_group);
+        sysfs_remove_group(&pdev->dev.kobj, &w83781d_group_opt);
+        device_remove_file(&pdev->dev, &dev_attr_name);
+        kfree(data);
+ exit_release_region:
+        release_region(res->start + W83781D_ADDR_REG_OFFSET, 2);
+ exit:
+        return err;
+}
+
+static int __devexit
+w83781d_isa_remove(struct platform_device *pdev)
+{
+        struct w83781d_data *data = platform_get_drvdata(pdev);
+
+        hwmon_device_unregister(data->hwmon_dev);
+        sysfs_remove_group(&pdev->dev.kobj, &w83781d_group);
+        sysfs_remove_group(&pdev->dev.kobj, &w83781d_group_opt);
+        device_remove_file(&pdev->dev, &dev_attr_name);
+        release_region(data->isa_addr + W83781D_ADDR_REG_OFFSET, 2);
+        kfree(data);
+
+        return 0;
+}
+
+static struct platform_driver w83781d_isa_driver = {
+        .driver = {
+                .owner = THIS_MODULE,
+                .name = "w83781d",
+        },
+        .probe = w83781d_isa_probe,
+        .remove = __devexit_p(w83781d_isa_remove),
+};
+
 /* return 1 if a supported chip is found, 0 otherwise */
 static int __init
 w83781d_isa_found(unsigned short address)
@@ -1928,18 +1945,14 @@ w83781d_isa_device_add(unsigned short address)
 }
 
 static int __init
-sensors_w83781d_init(void)
+w83781d_isa_register(void)
 {
         int res;
 
-        res = i2c_add_driver(&w83781d_driver);
-        if (res)
-                goto exit;
-
         if (w83781d_isa_found(isa_address)) {
                 res = platform_driver_register(&w83781d_isa_driver);
                 if (res)
-                        goto exit_unreg_i2c_driver;
+                        goto exit;
 
                 /* Sets global pdev as a side effect */
                 res = w83781d_isa_device_add(isa_address);
@@ -1949,21 +1962,94 @@ sensors_w83781d_init(void)
 
         return 0;
 
- exit_unreg_isa_driver:
+exit_unreg_isa_driver:
         platform_driver_unregister(&w83781d_isa_driver);
- exit_unreg_i2c_driver:
-        i2c_del_driver(&w83781d_driver);
- exit:
+exit:
         return res;
 }
 
-static void __exit
-sensors_w83781d_exit(void)
+static void
+w83781d_isa_unregister(void)
 {
         if (pdev) {
                 platform_device_unregister(pdev);
                 platform_driver_unregister(&w83781d_isa_driver);
         }
+}
+#else /* !CONFIG_ISA */
+
+static struct w83781d_data *w83781d_data_if_isa(void)
+{
+        return NULL;
+}
+
+static int
+w83781d_alias_detect(struct i2c_client *client, u8 chipid)
+{
+        return 0;
+}
+
+static int
+w83781d_read_value(struct w83781d_data *data, u16 reg)
+{
+        int res;
+
+        mutex_lock(&data->lock);
+        res = w83781d_read_value_i2c(data, reg);
+        mutex_unlock(&data->lock);
+
+        return res;
+}
+
+static int
+w83781d_write_value(struct w83781d_data *data, u16 reg, u16 value)
+{
+        mutex_lock(&data->lock);
+        w83781d_write_value_i2c(data, reg, value);
+        mutex_unlock(&data->lock);
+
+        return 0;
+}
+
+static int __init
+w83781d_isa_register(void)
+{
+        return 0;
+}
+
+static void
+w83781d_isa_unregister(void)
+{
+}
+#endif /* CONFIG_ISA */
+
+static int __init
+sensors_w83781d_init(void)
+{
+        int res;
+
+        /* We register the ISA device first, so that we can skip the
+         * registration of an I2C interface to the same device. */
+        res = w83781d_isa_register();
+        if (res)
+                goto exit;
+
+        res = i2c_add_driver(&w83781d_driver);
+        if (res)
+                goto exit_unreg_isa;
+
+        return 0;
+
+ exit_unreg_isa:
+        w83781d_isa_unregister();
+ exit:
+        return res;
+}
+
+static void __exit
+sensors_w83781d_exit(void)
+{
+        w83781d_isa_unregister();
         i2c_del_driver(&w83781d_driver);
 }
 
diff --git a/drivers/hwmon/w83791d.c b/drivers/hwmon/w83791d.c
index e4e91c9d480a..5768def8a4f2 100644
--- a/drivers/hwmon/w83791d.c
+++ b/drivers/hwmon/w83791d.c
@@ -23,7 +23,7 @@
     Supports following chips:
 
     Chip        #vin    #fanin  #pwm    #temp   wchipid vendid  i2c     ISA
-    w83791d     10      5       3       3       0x71    0x5ca3  yes     no
+    w83791d     10      5       5       3       0x71    0x5ca3  yes     no
 
     The w83791d chip appears to be part way between the 83781d and the
     83792d. Thus, this file is derived from both the w83792d.c and
@@ -45,6 +45,7 @@
 #define NUMBER_OF_VIN           10
 #define NUMBER_OF_FANIN         5
 #define NUMBER_OF_TEMPIN        3
+#define NUMBER_OF_PWM           5
 
 /* Addresses to scan */
 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, 0x2f,
@@ -116,6 +117,25 @@ static const u8 W83791D_REG_FAN_MIN[NUMBER_OF_FANIN] = {
         0xBD,                   /* FAN 5 Count Low Limit in DataSheet */
 };
 
+static const u8 W83791D_REG_PWM[NUMBER_OF_PWM] = {
+        0x81,                   /* PWM 1 duty cycle register in DataSheet */
+        0x83,                   /* PWM 2 duty cycle register in DataSheet */
+        0x94,                   /* PWM 3 duty cycle register in DataSheet */
+        0xA0,                   /* PWM 4 duty cycle register in DataSheet */
+        0xA1,                   /* PWM 5 duty cycle register in DataSheet */
+};
+
+static const u8 W83791D_REG_TEMP_TARGET[3] = {
+        0x85,                   /* PWM 1 target temperature for temp 1 */
+        0x86,                   /* PWM 2 target temperature for temp 2 */
+        0x96,                   /* PWM 3 target temperature for temp 3 */
+};
+
+static const u8 W83791D_REG_TEMP_TOL[2] = {
+        0x87,                   /* PWM 1/2 temperature tolerance */
+        0x97,                   /* PWM 3 temperature tolerance */
+};
+
 static const u8 W83791D_REG_FAN_CFG[2] = {
         0x84,                   /* FAN 1/2 configuration */
         0x95,                   /* FAN 3 configuration */
@@ -160,6 +180,7 @@ static const u8 W83791D_REG_BEEP_CTRL[3] = {
         0xA3,                   /* BEEP Control Register 3 */
 };
 
+#define W83791D_REG_GPIO                0x15
 #define W83791D_REG_CONFIG              0x40
 #define W83791D_REG_VID_FANDIV          0x47
 #define W83791D_REG_DID_VID4            0x49
@@ -224,6 +245,15 @@ static u8 fan_to_reg(long rpm, int div)
                                  (val) < 0 ? ((val) - 250) / 500 * 128 : \
                                  ((val) + 250) / 500 * 128)
 
+/* for thermal cruise target temp, 7-bits, LSB = 1 degree Celsius */
+#define TARGET_TEMP_TO_REG(val)         ((val) < 0 ? 0 : \
+                                        (val) >= 127000 ? 127 : \
+                                        ((val) + 500) / 1000)
+
+/* for thermal cruise temp tolerance, 4-bits, LSB = 1 degree Celsius */
+#define TOL_TEMP_TO_REG(val)            ((val) < 0 ? 0 : \
+                                        (val) >= 15000 ? 15 : \
+                                        ((val) + 500) / 1000)
 
 #define BEEP_MASK_TO_REG(val)           ((val) & 0xffffff)
 #define BEEP_MASK_FROM_REG(val)         ((val) & 0xffffff)
@@ -233,11 +263,9 @@ static u8 fan_to_reg(long rpm, int div)
 static u8 div_to_reg(int nr, long val)
 {
         int i;
-        int max;
 
-        /* first three fan's divisor max out at 8, rest max out at 128 */
-        max = (nr < 3) ? 8 : 128;
-        val = SENSORS_LIMIT(val, 1, max) >> 1;
+        /* fan divisors max out at 128 */
+        val = SENSORS_LIMIT(val, 1, 128) >> 1;
         for (i = 0; i < 7; i++) {
                 if (val == 0)
                         break;
@@ -277,6 +305,14 @@ struct w83791d_data {
                                    two sensors with three values
                                    (cur, over, hyst)  */
 
+        /* PWMs */
+        u8 pwm[5];              /* pwm duty cycle */
+        u8 pwm_enable[3];       /* pwm enable status for fan 1-3
+                                        (fan 4-5 only support manual mode) */
+
+        u8 temp_target[3];      /* pwm 1-3 target temperature */
+        u8 temp_tolerance[3];   /* pwm 1-3 temperature tolerance */
+
         /* Misc */
         u32 alarms;             /* realtime status register encoding,combined */
         u8 beep_enable;         /* Global beep enable */
@@ -530,6 +566,7 @@ static ssize_t store_fan_div(struct device *dev, struct device_attribute *attr,
         unsigned long min;
         u8 tmp_fan_div;
         u8 fan_div_reg;
+        u8 vbat_reg;
         int indx = 0;
         u8 keep_mask = 0;
         u8 new_shift = 0;
@@ -581,6 +618,16 @@ static ssize_t store_fan_div(struct device *dev, struct device_attribute *attr,
         w83791d_write(client, W83791D_REG_FAN_DIV[indx],
                                 fan_div_reg | tmp_fan_div);
 
+        /* Bit 2 of fans 0-2 is stored in the vbat register (bits 5-7) */
+        if (nr < 3) {
+                keep_mask = ~(1 << (nr + 5));
+                vbat_reg = w83791d_read(client, W83791D_REG_VBAT)
+                                & keep_mask;
+                tmp_fan_div = (data->fan_div[nr] << (3 + nr)) & ~keep_mask;
+                w83791d_write(client, W83791D_REG_VBAT,
+                                vbat_reg | tmp_fan_div);
+        }
+
         /* Restore fan_min */
         data->fan_min[nr] = fan_to_reg(min, DIV_FROM_REG(data->fan_div[nr]));
         w83791d_write(client, W83791D_REG_FAN_MIN[nr], data->fan_min[nr]);
@@ -643,6 +690,217 @@ static struct sensor_device_attribute sda_fan_alarm[] = {
         SENSOR_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL, 22),
 };
 
+/* read/write PWMs */
+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 w83791d_data *data = w83791d_update_device(dev);
+        return sprintf(buf, "%u\n", data->pwm[nr]);
+}
+
+static ssize_t store_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);
+        struct i2c_client *client = to_i2c_client(dev);
+        struct w83791d_data *data = i2c_get_clientdata(client);
+        int nr = sensor_attr->index;
+        unsigned long val;
+
+        if (strict_strtoul(buf, 10, &val))
+                return -EINVAL;
+
+        mutex_lock(&data->update_lock);
+        data->pwm[nr] = SENSORS_LIMIT(val, 0, 255);
+        w83791d_write(client, W83791D_REG_PWM[nr], data->pwm[nr]);
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+
+static struct sensor_device_attribute sda_pwm[] = {
+        SENSOR_ATTR(pwm1, S_IWUSR | S_IRUGO,
+                        show_pwm, store_pwm, 0),
+        SENSOR_ATTR(pwm2, S_IWUSR | S_IRUGO,
+                        show_pwm, store_pwm, 1),
+        SENSOR_ATTR(pwm3, S_IWUSR | S_IRUGO,
+                        show_pwm, store_pwm, 2),
+        SENSOR_ATTR(pwm4, S_IWUSR | S_IRUGO,
+                        show_pwm, store_pwm, 3),
+        SENSOR_ATTR(pwm5, S_IWUSR | S_IRUGO,
+                        show_pwm, store_pwm, 4),
+};
+
+static ssize_t show_pwmenable(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 w83791d_data *data = w83791d_update_device(dev);
+        return sprintf(buf, "%u\n", data->pwm_enable[nr] + 1);
+}
+
+static ssize_t store_pwmenable(struct device *dev,
+                struct device_attribute *attr, const char *buf, size_t count)
+{
+        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
+        struct i2c_client *client = to_i2c_client(dev);
+        struct w83791d_data *data = i2c_get_clientdata(client);
+        int nr = sensor_attr->index;
+        unsigned long val;
+        u8 reg_cfg_tmp;
+        u8 reg_idx = 0;
+        u8 val_shift = 0;
+        u8 keep_mask = 0;
+
+        int ret = strict_strtoul(buf, 10, &val);
+
+        if (ret || val < 1 || val > 3)
+                return -EINVAL;
+
+        mutex_lock(&data->update_lock);
+        data->pwm_enable[nr] = val - 1;
+        switch (nr) {
+        case 0:
+                reg_idx = 0;
+                val_shift = 2;
+                keep_mask = 0xf3;
+                break;
+        case 1:
+                reg_idx = 0;
+                val_shift = 4;
+                keep_mask = 0xcf;
+                break;
+        case 2:
+                reg_idx = 1;
+                val_shift = 2;
+                keep_mask = 0xf3;
+                break;
+        }
+
+        reg_cfg_tmp = w83791d_read(client, W83791D_REG_FAN_CFG[reg_idx]);
+        reg_cfg_tmp = (reg_cfg_tmp & keep_mask) |
+                                        data->pwm_enable[nr] << val_shift;
+
+        w83791d_write(client, W83791D_REG_FAN_CFG[reg_idx], reg_cfg_tmp);
+        mutex_unlock(&data->update_lock);
+
+        return count;
+}
+static struct sensor_device_attribute sda_pwmenable[] = {
+        SENSOR_ATTR(pwm1_enable, S_IWUSR | S_IRUGO,
+                        show_pwmenable, store_pwmenable, 0),
+        SENSOR_ATTR(pwm2_enable, S_IWUSR | S_IRUGO,
+                        show_pwmenable, store_pwmenable, 1),
+        SENSOR_ATTR(pwm3_enable, S_IWUSR | S_IRUGO,
+                        show_pwmenable, store_pwmenable, 2),
+};
+
+/* For Smart Fan I / Thermal Cruise */
+static ssize_t show_temp_target(struct device *dev,
+                        struct device_attribute *attr, char *buf)
+{
+        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
+        struct w83791d_data *data = w83791d_update_device(dev);
+        int nr = sensor_attr->index;
+        return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp_target[nr]));
+}
+
+static ssize_t store_temp_target(struct device *dev,
+                struct device_attribute *attr, const char *buf, size_t count)
+{
+        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
+        struct i2c_client *client = to_i2c_client(dev);
+        struct w83791d_data *data = i2c_get_clientdata(client);
+        int nr = sensor_attr->index;
+        unsigned long val;
+        u8 target_mask;
+
+        if (strict_strtoul(buf, 10, &val))
+                return -EINVAL;
+
+        mutex_lock(&data->update_lock);
+        data->temp_target[nr] = TARGET_TEMP_TO_REG(val);
+        target_mask = w83791d_read(client,
+                                W83791D_REG_TEMP_TARGET[nr]) & 0x80;
+        w83791d_write(client, W83791D_REG_TEMP_TARGET[nr],
+                                data->temp_target[nr] | target_mask);
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+
+static struct sensor_device_attribute sda_temp_target[] = {
+        SENSOR_ATTR(temp1_target, S_IWUSR | S_IRUGO,
+                        show_temp_target, store_temp_target, 0),
+        SENSOR_ATTR(temp2_target, S_IWUSR | S_IRUGO,
+                        show_temp_target, store_temp_target, 1),
+        SENSOR_ATTR(temp3_target, S_IWUSR | S_IRUGO,
+                        show_temp_target, store_temp_target, 2),
+};
+
+static ssize_t show_temp_tolerance(struct device *dev,
+                        struct device_attribute *attr, char *buf)
+{
+        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
+        struct w83791d_data *data = w83791d_update_device(dev);
+        int nr = sensor_attr->index;
+        return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp_tolerance[nr]));
+}
+
+static ssize_t store_temp_tolerance(struct device *dev,
+                struct device_attribute *attr, const char *buf, size_t count)
+{
+        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
+        struct i2c_client *client = to_i2c_client(dev);
+        struct w83791d_data *data = i2c_get_clientdata(client);
+        int nr = sensor_attr->index;
+        unsigned long val;
+        u8 target_mask;
+        u8 reg_idx = 0;
+        u8 val_shift = 0;
+        u8 keep_mask = 0;
+
+        if (strict_strtoul(buf, 10, &val))
+                return -EINVAL;
+
+        switch (nr) {
+        case 0:
+                reg_idx = 0;
+                val_shift = 0;
+                keep_mask = 0xf0;
+                break;
+        case 1:
+                reg_idx = 0;
+                val_shift = 4;
+                keep_mask = 0x0f;
+                break;
+        case 2:
+                reg_idx = 1;
+                val_shift = 0;
+                keep_mask = 0xf0;
+                break;
+        }
+
+        mutex_lock(&data->update_lock);
+        data->temp_tolerance[nr] = TOL_TEMP_TO_REG(val);
+        target_mask = w83791d_read(client,
+                        W83791D_REG_TEMP_TOL[reg_idx]) & keep_mask;
+        w83791d_write(client, W83791D_REG_TEMP_TOL[reg_idx],
+                        (data->temp_tolerance[nr] << val_shift) | target_mask);
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+
+static struct sensor_device_attribute sda_temp_tolerance[] = {
+        SENSOR_ATTR(temp1_tolerance, S_IWUSR | S_IRUGO,
+                        show_temp_tolerance, store_temp_tolerance, 0),
+        SENSOR_ATTR(temp2_tolerance, S_IWUSR | S_IRUGO,
+                        show_temp_tolerance, store_temp_tolerance, 1),
+        SENSOR_ATTR(temp3_tolerance, S_IWUSR | S_IRUGO,
+                        show_temp_tolerance, store_temp_tolerance, 2),
+};
+
 /* read/write the temperature1, includes measured value and limits */
 static ssize_t show_temp1(struct device *dev, struct device_attribute *devattr,
                                 char *buf)
@@ -899,8 +1157,6 @@ static struct attribute *w83791d_attributes[] = {
         FAN_UNIT_ATTRS(0),
         FAN_UNIT_ATTRS(1),
         FAN_UNIT_ATTRS(2),
-        FAN_UNIT_ATTRS(3),
-        FAN_UNIT_ATTRS(4),
         TEMP_UNIT_ATTRS(0),
         TEMP_UNIT_ATTRS(1),
         TEMP_UNIT_ATTRS(2),
@@ -909,6 +1165,18 @@ static struct attribute *w83791d_attributes[] = {
         &sda_beep_ctrl[1].dev_attr.attr,
         &dev_attr_cpu0_vid.attr,
         &dev_attr_vrm.attr,
+        &sda_pwm[0].dev_attr.attr,
+        &sda_pwm[1].dev_attr.attr,
+        &sda_pwm[2].dev_attr.attr,
+        &sda_pwmenable[0].dev_attr.attr,
+        &sda_pwmenable[1].dev_attr.attr,
+        &sda_pwmenable[2].dev_attr.attr,
+        &sda_temp_target[0].dev_attr.attr,
+        &sda_temp_target[1].dev_attr.attr,
+        &sda_temp_target[2].dev_attr.attr,
+        &sda_temp_tolerance[0].dev_attr.attr,
+        &sda_temp_tolerance[1].dev_attr.attr,
+        &sda_temp_tolerance[2].dev_attr.attr,
         NULL
 };
 
@@ -916,6 +1184,20 @@ static const struct attribute_group w83791d_group = {
         .attrs = w83791d_attributes,
 };
 
+/* Separate group of attributes for fan/pwm 4-5. Their pins can also be
+   in use for GPIO in which case their sysfs-interface should not be made
+   available */
+static struct attribute *w83791d_attributes_fanpwm45[] = {
+        FAN_UNIT_ATTRS(3),
+        FAN_UNIT_ATTRS(4),
+        &sda_pwm[3].dev_attr.attr,
+        &sda_pwm[4].dev_attr.attr,
+        NULL
+};
+
+static const struct attribute_group w83791d_group_fanpwm45 = {
+        .attrs = w83791d_attributes_fanpwm45,
+};
 
 static int w83791d_detect_subclients(struct i2c_client *client)
 {
@@ -1046,9 +1328,11 @@ static int w83791d_probe(struct i2c_client *client,
 {
         struct w83791d_data *data;
         struct device *dev = &client->dev;
-        int i, val1, err;
+        int i, err;
+        u8 has_fanpwm45;
 
 #ifdef DEBUG
+        int val1;
         val1 = w83791d_read(client, W83791D_REG_DID_VID4);
         dev_dbg(dev, "Device ID version: %d.%d (0x%02x)\n",
                         (val1 >> 5) & 0x07, (val1 >> 1) & 0x0f, val1);
@@ -1080,15 +1364,27 @@ static int w83791d_probe(struct i2c_client *client,
         if ((err = sysfs_create_group(&client->dev.kobj, &w83791d_group)))
                 goto error3;
 
+        /* Check if pins of fan/pwm 4-5 are in use as GPIO */
+        has_fanpwm45 = w83791d_read(client, W83791D_REG_GPIO) & 0x10;
+        if (has_fanpwm45) {
+                err = sysfs_create_group(&client->dev.kobj,
+                                         &w83791d_group_fanpwm45);
+                if (err)
+                        goto error4;
+        }
+
         /* Everything is ready, now register the working device */
         data->hwmon_dev = hwmon_device_register(dev);
         if (IS_ERR(data->hwmon_dev)) {
                 err = PTR_ERR(data->hwmon_dev);
-                goto error4;
+                goto error5;
         }
 
         return 0;
 
+error5:
+        if (has_fanpwm45)
+                sysfs_remove_group(&client->dev.kobj, &w83791d_group_fanpwm45);
 error4:
         sysfs_remove_group(&client->dev.kobj, &w83791d_group);
 error3:
@@ -1182,6 +1478,7 @@ static struct w83791d_data *w83791d_update_device(struct device *dev)
         struct w83791d_data *data = i2c_get_clientdata(client);
         int i, j;
         u8 reg_array_tmp[3];
+        u8 vbat_reg;
 
         mutex_lock(&data->update_lock);
 
@@ -1219,6 +1516,42 @@ static struct w83791d_data *w83791d_update_device(struct device *dev)
                 data->fan_div[3] = reg_array_tmp[2] & 0x07;
                 data->fan_div[4] = (reg_array_tmp[2] >> 4) & 0x07;
 
+                /* The fan divisor for fans 0-2 get bit 2 from
+                   bits 5-7 respectively of vbat register */
+                vbat_reg = w83791d_read(client, W83791D_REG_VBAT);
+                for (i = 0; i < 3; i++)
+                        data->fan_div[i] |= (vbat_reg >> (3 + i)) & 0x04;
+
+                /* Update PWM duty cycle */
+                for (i = 0; i < NUMBER_OF_PWM; i++) {
+                        data->pwm[i] =  w83791d_read(client,
+                                                W83791D_REG_PWM[i]);
+                }
+
+                /* Update PWM enable status */
+                for (i = 0; i < 2; i++) {
+                        reg_array_tmp[i] = w83791d_read(client,
+                                                W83791D_REG_FAN_CFG[i]);
+                }
+                data->pwm_enable[0] = (reg_array_tmp[0] >> 2) & 0x03;
+                data->pwm_enable[1] = (reg_array_tmp[0] >> 4) & 0x03;
+                data->pwm_enable[2] = (reg_array_tmp[1] >> 2) & 0x03;
+
+                /* Update PWM target temperature */
+                for (i = 0; i < 3; i++) {
+                        data->temp_target[i] = w83791d_read(client,
+                                W83791D_REG_TEMP_TARGET[i]) & 0x7f;
+                }
+
+                /* Update PWM temperature tolerance */
+                for (i = 0; i < 2; i++) {
+                        reg_array_tmp[i] = w83791d_read(client,
+                                        W83791D_REG_TEMP_TOL[i]);
+                }
+                data->temp_tolerance[0] = reg_array_tmp[0] & 0x0f;
+                data->temp_tolerance[1] = (reg_array_tmp[0] >> 4) & 0x0f;
+                data->temp_tolerance[2] = reg_array_tmp[1] & 0x0f;
+
                 /* Update the first temperature sensor */
                 for (i = 0; i < 3; i++) {
                         data->temp1[i] = w83791d_read(client,