Merge branch 'hwmon-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/groeck/linux-staging

* 'hwmon-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/groeck/linux-staging: (26 commits)
  hwmon: (w83627ehf) Better fix for negative temperature values
  hwmon: (w83627ehf) Uninline is_word_sized
  hwmon: (lm75) Document why clones are not detected
  hwmon: (w83627ehf) Move fan pins check to a separate function
  hwmon: (w83627ehf) Skip reading unused voltage registers
  hwmon: (lm75) Add support for Analog Devices ADT75
  hwmon: (pmbus_core) Simplify sign extensions
  hwmon: (pmbus) Add support for Lineage Power DC-DC converters
  hwmon: (pmbus/ltc2978) Add support for LTC3880 to LTC2978 driver
  hwmon: (pmbus/ltc2978) Explicit driver for LTC2978
  hwmon: (pmbus) Add support for TEMP2 peak attributes
  hwmon: AD7314 driver (ported from IIO)
  hwmon: (pmbus) Add support for Intersil power management chips
  hwmon: (pmbus) Always call _pmbus_read_byte in core driver
  hwmon: (pmbus) Replace EINVAL return codes with more appropriate errors
  hwmon: (pmbus) Provide more documentation
  hwmon/f71882fg: Make the decision wether to register fan attr. per fan
  hwmon/f71882fg: Add a f71882fg_create_fan_sysfs_files helper function
  hwmon/f71882fg: Make all fan/pwm attr tables 2 dimensional
  hwmon: (exynos4_tmu) Remove IRQF_DISABLED
  ...

14 files changed, 944 insertions, 87 deletions

diff --git a/drivers/hwmon/pmbus/Kconfig b/drivers/hwmon/pmbus/Kconfig
index c9237b9dcff..4b26f51920b 100644
--- a/drivers/hwmon/pmbus/Kconfig
+++ b/drivers/hwmon/pmbus/Kconfig
@@ -20,17 +20,18 @@ config SENSORS_PMBUS
         help
           If you say yes here you get hardware monitoring support for generic
           PMBus devices, including but not limited to ADP4000, BMR450, BMR451,
-          BMR453, BMR454, LTC2978, NCP4200, and NCP4208.
+          BMR453, BMR454, NCP4200, and NCP4208.
 
           This driver can also be built as a module. If so, the module will
           be called pmbus.
 
 config SENSORS_ADM1275
-        tristate "Analog Devices ADM1275"
+        tristate "Analog Devices ADM1275 and compatibles"
         default n
         help
           If you say yes here you get hardware monitoring support for Analog
-          Devices ADM1275 Hot-Swap Controller and Digital Power Monitor.
+          Devices ADM1275 and ADM1276 Hot-Swap Controller and Digital Power
+          Monitor.
 
           This driver can also be built as a module. If so, the module will
           be called adm1275.
@@ -45,6 +46,16 @@ config SENSORS_LM25066
           This driver can also be built as a module. If so, the module will
           be called lm25066.
 
+config SENSORS_LTC2978
+        tristate "Linear Technologies LTC2978 and LTC3880"
+        default n
+        help
+          If you say yes here you get hardware monitoring support for Linear
+          Technology LTC2978 and LTC3880.
+
+          This driver can also be built as a module. If so, the module will
+          be called ltc2978.
+
 config SENSORS_MAX16064
         tristate "Maxim MAX16064"
         default n
@@ -97,4 +108,15 @@ config SENSORS_UCD9200
           This driver can also be built as a module. If so, the module will
           be called ucd9200.
 
+config SENSORS_ZL6100
+        tristate "Intersil ZL6100 and compatibles"
+        default n
+        help
+          If you say yes here you get hardware monitoring support for Intersil
+          ZL2004, ZL2006, ZL2008, ZL2105, ZL2106, ZL6100, and ZL6105 Digital
+          DC/DC Controllers.
+
+          This driver can also be built as a module. If so, the module will
+          be called zl6100.
+
 endif # PMBUS
diff --git a/drivers/hwmon/pmbus/Makefile b/drivers/hwmon/pmbus/Makefile
index 623eedb1ed9..789376c85db 100644
--- a/drivers/hwmon/pmbus/Makefile
+++ b/drivers/hwmon/pmbus/Makefile
@@ -6,8 +6,10 @@ obj-$(CONFIG_PMBUS)		+= pmbus_core.o
 obj-$(CONFIG_SENSORS_PMBUS)     += pmbus.o
 obj-$(CONFIG_SENSORS_ADM1275)   += adm1275.o
 obj-$(CONFIG_SENSORS_LM25066)   += lm25066.o
+obj-$(CONFIG_SENSORS_LTC2978)   += ltc2978.o
 obj-$(CONFIG_SENSORS_MAX16064)  += max16064.o
 obj-$(CONFIG_SENSORS_MAX34440)  += max34440.o
 obj-$(CONFIG_SENSORS_MAX8688)   += max8688.o
 obj-$(CONFIG_SENSORS_UCD9000)   += ucd9000.o
 obj-$(CONFIG_SENSORS_UCD9200)   += ucd9200.o
+obj-$(CONFIG_SENSORS_ZL6100)    += zl6100.o
diff --git a/drivers/hwmon/pmbus/adm1275.c b/drivers/hwmon/pmbus/adm1275.c
index c936e278230..980a4d9d502 100644
--- a/drivers/hwmon/pmbus/adm1275.c
+++ b/drivers/hwmon/pmbus/adm1275.c
@@ -23,6 +23,8 @@
 #include <linux/i2c.h>
 #include "pmbus.h"
 
+enum chips { adm1275, adm1276 };
+
 #define ADM1275_PEAK_IOUT               0xd0
 #define ADM1275_PEAK_VIN                0xd1
 #define ADM1275_PEAK_VOUT               0xd2
@@ -31,14 +33,47 @@
 #define ADM1275_VIN_VOUT_SELECT         (1 << 6)
 #define ADM1275_VRANGE                  (1 << 5)
 
+#define ADM1275_IOUT_WARN2_LIMIT        0xd7
+#define ADM1275_DEVICE_CONFIG           0xd8
+
+#define ADM1275_IOUT_WARN2_SELECT       (1 << 4)
+
+#define ADM1276_PEAK_PIN                0xda
+
+#define ADM1275_MFR_STATUS_IOUT_WARN2   (1 << 0)
+
+struct adm1275_data {
+        int id;
+        bool have_oc_fault;
+        struct pmbus_driver_info info;
+};
+
+#define to_adm1275_data(x)  container_of(x, struct adm1275_data, info)
+
 static int adm1275_read_word_data(struct i2c_client *client, int page, int reg)
 {
-        int ret;
+        const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
+        const struct adm1275_data *data = to_adm1275_data(info);
+        int ret = 0;
 
         if (page)
-                return -EINVAL;
+                return -ENXIO;
 
         switch (reg) {
+        case PMBUS_IOUT_UC_FAULT_LIMIT:
+                if (data->have_oc_fault) {
+                        ret = -ENXIO;
+                        break;
+                }
+                ret = pmbus_read_word_data(client, 0, ADM1275_IOUT_WARN2_LIMIT);
+                break;
+        case PMBUS_IOUT_OC_FAULT_LIMIT:
+                if (!data->have_oc_fault) {
+                        ret = -ENXIO;
+                        break;
+                }
+                ret = pmbus_read_word_data(client, 0, ADM1275_IOUT_WARN2_LIMIT);
+                break;
         case PMBUS_VIRT_READ_IOUT_MAX:
                 ret = pmbus_read_word_data(client, 0, ADM1275_PEAK_IOUT);
                 break;
@@ -48,10 +83,20 @@ static int adm1275_read_word_data(struct i2c_client *client, int page, int reg)
         case PMBUS_VIRT_READ_VIN_MAX:
                 ret = pmbus_read_word_data(client, 0, ADM1275_PEAK_VIN);
                 break;
+        case PMBUS_VIRT_READ_PIN_MAX:
+                if (data->id != adm1276) {
+                        ret = -ENXIO;
+                        break;
+                }
+                ret = pmbus_read_word_data(client, 0, ADM1276_PEAK_PIN);
+                break;
         case PMBUS_VIRT_RESET_IOUT_HISTORY:
         case PMBUS_VIRT_RESET_VOUT_HISTORY:
         case PMBUS_VIRT_RESET_VIN_HISTORY:
-                ret = 0;
+                break;
+        case PMBUS_VIRT_RESET_PIN_HISTORY:
+                if (data->id != adm1276)
+                        ret = -ENXIO;
                 break;
         default:
                 ret = -ENODATA;
@@ -66,9 +111,14 @@ static int adm1275_write_word_data(struct i2c_client *client, int page, int reg,
         int ret;
 
         if (page)
-                return -EINVAL;
+                return -ENXIO;
 
         switch (reg) {
+        case PMBUS_IOUT_UC_FAULT_LIMIT:
+        case PMBUS_IOUT_OC_FAULT_LIMIT:
+                ret = pmbus_write_word_data(client, 0, ADM1275_IOUT_WARN2_LIMIT,
+                                            word);
+                break;
         case PMBUS_VIRT_RESET_IOUT_HISTORY:
                 ret = pmbus_write_word_data(client, 0, ADM1275_PEAK_IOUT, 0);
                 break;
@@ -78,6 +128,41 @@ static int adm1275_write_word_data(struct i2c_client *client, int page, int reg,
         case PMBUS_VIRT_RESET_VIN_HISTORY:
                 ret = pmbus_write_word_data(client, 0, ADM1275_PEAK_VIN, 0);
                 break;
+        case PMBUS_VIRT_RESET_PIN_HISTORY:
+                ret = pmbus_write_word_data(client, 0, ADM1276_PEAK_PIN, 0);
+                break;
+        default:
+                ret = -ENODATA;
+                break;
+        }
+        return ret;
+}
+
+static int adm1275_read_byte_data(struct i2c_client *client, int page, int reg)
+{
+        const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
+        const struct adm1275_data *data = to_adm1275_data(info);
+        int mfr_status, ret;
+
+        if (page > 0)
+                return -ENXIO;
+
+        switch (reg) {
+        case PMBUS_STATUS_IOUT:
+                ret = pmbus_read_byte_data(client, page, PMBUS_STATUS_IOUT);
+                if (ret < 0)
+                        break;
+                mfr_status = pmbus_read_byte_data(client, page,
+                                                  PMBUS_STATUS_MFR_SPECIFIC);
+                if (mfr_status < 0) {
+                        ret = mfr_status;
+                        break;
+                }
+                if (mfr_status & ADM1275_MFR_STATUS_IOUT_WARN2) {
+                        ret |= data->have_oc_fault ?
+                          PB_IOUT_OC_FAULT : PB_IOUT_UC_FAULT;
+                }
+                break;
         default:
                 ret = -ENODATA;
                 break;
@@ -88,16 +173,17 @@ static int adm1275_write_word_data(struct i2c_client *client, int page, int reg,
 static int adm1275_probe(struct i2c_client *client,
                          const struct i2c_device_id *id)
 {
-        int config;
+        int config, device_config;
         int ret;
         struct pmbus_driver_info *info;
+        struct adm1275_data *data;
 
         if (!i2c_check_functionality(client->adapter,
                                      I2C_FUNC_SMBUS_READ_BYTE_DATA))
                 return -ENODEV;
 
-        info = kzalloc(sizeof(struct pmbus_driver_info), GFP_KERNEL);
-        if (!info)
+        data = kzalloc(sizeof(struct adm1275_data), GFP_KERNEL);
+        if (!data)
                 return -ENOMEM;
 
         config = i2c_smbus_read_byte_data(client, ADM1275_PMON_CONFIG);
@@ -106,6 +192,15 @@ static int adm1275_probe(struct i2c_client *client,
                 goto err_mem;
         }
 
+        device_config = i2c_smbus_read_byte_data(client, ADM1275_DEVICE_CONFIG);
+        if (device_config < 0) {
+                ret = device_config;
+                goto err_mem;
+        }
+
+        data->id = id->driver_data;
+        info = &data->info;
+
         info->pages = 1;
         info->format[PSC_VOLTAGE_IN] = direct;
         info->format[PSC_VOLTAGE_OUT] = direct;
@@ -116,6 +211,7 @@ static int adm1275_probe(struct i2c_client *client,
         info->func[0] = PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT;
 
         info->read_word_data = adm1275_read_word_data;
+        info->read_byte_data = adm1275_read_byte_data;
         info->write_word_data = adm1275_write_word_data;
 
         if (config & ADM1275_VRANGE) {
@@ -134,10 +230,36 @@ static int adm1275_probe(struct i2c_client *client,
                 info->R[PSC_VOLTAGE_OUT] = -1;
         }
 
-        if (config & ADM1275_VIN_VOUT_SELECT)
-                info->func[0] |= PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT;
-        else
-                info->func[0] |= PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT;
+        if (device_config & ADM1275_IOUT_WARN2_SELECT)
+                data->have_oc_fault = true;
+
+        switch (id->driver_data) {
+        case adm1275:
+                if (config & ADM1275_VIN_VOUT_SELECT)
+                        info->func[0] |=
+                          PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT;
+                else
+                        info->func[0] |=
+                          PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT;
+                break;
+        case adm1276:
+                info->format[PSC_POWER] = direct;
+                info->func[0] |= PMBUS_HAVE_VIN | PMBUS_HAVE_PIN
+                  | PMBUS_HAVE_STATUS_INPUT;
+                if (config & ADM1275_VIN_VOUT_SELECT)
+                        info->func[0] |=
+                          PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT;
+                if (config & ADM1275_VRANGE) {
+                        info->m[PSC_POWER] = 6043;
+                        info->b[PSC_POWER] = 0;
+                        info->R[PSC_POWER] = -2;
+                } else {
+                        info->m[PSC_POWER] = 2115;
+                        info->b[PSC_POWER] = 0;
+                        info->R[PSC_POWER] = -1;
+                }
+                break;
+        }
 
         ret = pmbus_do_probe(client, id, info);
         if (ret)
@@ -145,22 +267,23 @@ static int adm1275_probe(struct i2c_client *client,
         return 0;
 
 err_mem:
-        kfree(info);
+        kfree(data);
         return ret;
 }
 
 static int adm1275_remove(struct i2c_client *client)
 {
         const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
-        int ret;
+        const struct adm1275_data *data = to_adm1275_data(info);
 
-        ret = pmbus_do_remove(client);
-        kfree(info);
-        return ret;
+        pmbus_do_remove(client);
+        kfree(data);
+        return 0;
 }
 
 static const struct i2c_device_id adm1275_id[] = {
-        {"adm1275", 0},
+        { "adm1275", adm1275 },
+        { "adm1276", adm1276 },
         { }
 };
 MODULE_DEVICE_TABLE(i2c, adm1275_id);
@@ -185,7 +308,7 @@ static void __exit adm1275_exit(void)
 }
 
 MODULE_AUTHOR("Guenter Roeck");
-MODULE_DESCRIPTION("PMBus driver for Analog Devices ADM1275");
+MODULE_DESCRIPTION("PMBus driver for Analog Devices ADM1275 and compatibles");
 MODULE_LICENSE("GPL");
 module_init(adm1275_init);
 module_exit(adm1275_exit);
diff --git a/drivers/hwmon/pmbus/lm25066.c b/drivers/hwmon/pmbus/lm25066.c
index ac254fba551..84a37f0c8db 100644
--- a/drivers/hwmon/pmbus/lm25066.c
+++ b/drivers/hwmon/pmbus/lm25066.c
@@ -57,7 +57,7 @@ static int lm25066_read_word_data(struct i2c_client *client, int page, int reg)
         int ret;
 
         if (page > 1)
-                return -EINVAL;
+                return -ENXIO;
 
         /* Map READ_VAUX into READ_VOUT register on page 1 */
         if (page == 1) {
@@ -85,7 +85,7 @@ static int lm25066_read_word_data(struct i2c_client *client, int page, int reg)
                         break;
                 default:
                         /* No other valid registers on page 1 */
-                        ret = -EINVAL;
+                        ret = -ENXIO;
                         break;
                 }
                 goto done;
@@ -138,7 +138,7 @@ static int lm25066_write_word_data(struct i2c_client *client, int page, int reg,
         int ret;
 
         if (page > 1)
-                return -EINVAL;
+                return -ENXIO;
 
         switch (reg) {
         case PMBUS_IIN_OC_WARN_LIMIT:
@@ -164,10 +164,10 @@ static int lm25066_write_word_data(struct i2c_client *client, int page, int reg,
 static int lm25066_write_byte(struct i2c_client *client, int page, u8 value)
 {
         if (page > 1)
-                return -EINVAL;
+                return -ENXIO;
 
-        if (page == 0)
-                return pmbus_write_byte(client, 0, value);
+        if (page <= 0)
+                return pmbus_write_byte(client, page, value);
 
         return 0;
 }
@@ -309,11 +309,10 @@ static int lm25066_remove(struct i2c_client *client)
 {
         const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
         const struct lm25066_data *data = to_lm25066_data(info);
-        int ret;
 
-        ret = pmbus_do_remove(client);
+        pmbus_do_remove(client);
         kfree(data);
-        return ret;
+        return 0;
 }
 
 static const struct i2c_device_id lm25066_id[] = {
diff --git a/drivers/hwmon/pmbus/ltc2978.c b/drivers/hwmon/pmbus/ltc2978.c
new file mode 100644
index 00000000000..820fff48910
--- /dev/null
+++ b/drivers/hwmon/pmbus/ltc2978.c
@@ -0,0 +1,408 @@
+/*
+ * Hardware monitoring driver for LTC2978 and LTC3880
+ *
+ * Copyright (c) 2011 Ericsson AB.
+ *
+ * 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/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/err.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include "pmbus.h"
+
+enum chips { ltc2978, ltc3880 };
+
+/* LTC2978 and LTC3880 */
+#define LTC2978_MFR_VOUT_PEAK           0xdd
+#define LTC2978_MFR_VIN_PEAK            0xde
+#define LTC2978_MFR_TEMPERATURE_PEAK    0xdf
+#define LTC2978_MFR_SPECIAL_ID          0xe7
+
+/* LTC2978 only */
+#define LTC2978_MFR_VOUT_MIN            0xfb
+#define LTC2978_MFR_VIN_MIN             0xfc
+#define LTC2978_MFR_TEMPERATURE_MIN     0xfd
+
+/* LTC3880 only */
+#define LTC3880_MFR_IOUT_PEAK           0xd7
+#define LTC3880_MFR_CLEAR_PEAKS         0xe3
+#define LTC3880_MFR_TEMPERATURE2_PEAK   0xf4
+
+#define LTC2978_ID_REV1                 0x0121
+#define LTC2978_ID_REV2                 0x0122
+#define LTC3880_ID                      0x4000
+#define LTC3880_ID_MASK                 0xff00
+
+/*
+ * LTC2978 clears peak data whenever the CLEAR_FAULTS command is executed, which
+ * happens pretty much each time chip data is updated. Raw peak data therefore
+ * does not provide much value. To be able to provide useful peak data, keep an
+ * internal cache of measured peak data, which is only cleared if an explicit
+ * "clear peak" command is executed for the sensor in question.
+ */
+struct ltc2978_data {
+        enum chips id;
+        int vin_min, vin_max;
+        int temp_min, temp_max;
+        int vout_min[8], vout_max[8];
+        int iout_max[2];
+        int temp2_max[2];
+        struct pmbus_driver_info info;
+};
+
+#define to_ltc2978_data(x)  container_of(x, struct ltc2978_data, info)
+
+static inline int lin11_to_val(int data)
+{
+        s16 e = ((s16)data) >> 11;
+        s32 m = (((s16)(data << 5)) >> 5);
+
+        /*
+         * mantissa is 10 bit + sign, exponent adds up to 15 bit.
+         * Add 6 bit to exponent for maximum accuracy (10 + 15 + 6 = 31).
+         */
+        e += 6;
+        return (e < 0 ? m >> -e : m << e);
+}
+
+static int ltc2978_read_word_data_common(struct i2c_client *client, int page,
+                                         int reg)
+{
+        const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
+        struct ltc2978_data *data = to_ltc2978_data(info);
+        int ret;
+
+        switch (reg) {
+        case PMBUS_VIRT_READ_VIN_MAX:
+                ret = pmbus_read_word_data(client, page, LTC2978_MFR_VIN_PEAK);
+                if (ret >= 0) {
+                        if (lin11_to_val(ret) > lin11_to_val(data->vin_max))
+                                data->vin_max = ret;
+                        ret = data->vin_max;
+                }
+                break;
+        case PMBUS_VIRT_READ_VOUT_MAX:
+                ret = pmbus_read_word_data(client, page, LTC2978_MFR_VOUT_PEAK);
+                if (ret >= 0) {
+                        /*
+                         * VOUT is 16 bit unsigned with fixed exponent,
+                         * so we can compare it directly
+                         */
+                        if (ret > data->vout_max[page])
+                                data->vout_max[page] = ret;
+                        ret = data->vout_max[page];
+                }
+                break;
+        case PMBUS_VIRT_READ_TEMP_MAX:
+                ret = pmbus_read_word_data(client, page,
+                                           LTC2978_MFR_TEMPERATURE_PEAK);
+                if (ret >= 0) {
+                        if (lin11_to_val(ret) > lin11_to_val(data->temp_max))
+                                data->temp_max = ret;
+                        ret = data->temp_max;
+                }
+                break;
+        case PMBUS_VIRT_RESET_VOUT_HISTORY:
+        case PMBUS_VIRT_RESET_VIN_HISTORY:
+        case PMBUS_VIRT_RESET_TEMP_HISTORY:
+                ret = 0;
+                break;
+        default:
+                ret = -ENODATA;
+                break;
+        }
+        return ret;
+}
+
+static int ltc2978_read_word_data(struct i2c_client *client, int page, int reg)
+{
+        const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
+        struct ltc2978_data *data = to_ltc2978_data(info);
+        int ret;
+
+        switch (reg) {
+        case PMBUS_VIRT_READ_VIN_MIN:
+                ret = pmbus_read_word_data(client, page, LTC2978_MFR_VIN_MIN);
+                if (ret >= 0) {
+                        if (lin11_to_val(ret) < lin11_to_val(data->vin_min))
+                                data->vin_min = ret;
+                        ret = data->vin_min;
+                }
+                break;
+        case PMBUS_VIRT_READ_VOUT_MIN:
+                ret = pmbus_read_word_data(client, page, LTC2978_MFR_VOUT_MIN);
+                if (ret >= 0) {
+                        /*
+                         * VOUT_MIN is known to not be supported on some lots
+                         * of LTC2978 revision 1, and will return the maximum
+                         * possible voltage if read. If VOUT_MAX is valid and
+                         * lower than the reading of VOUT_MIN, use it instead.
+                         */
+                        if (data->vout_max[page] && ret > data->vout_max[page])
+                                ret = data->vout_max[page];
+                        if (ret < data->vout_min[page])
+                                data->vout_min[page] = ret;
+                        ret = data->vout_min[page];
+                }
+                break;
+        case PMBUS_VIRT_READ_TEMP_MIN:
+                ret = pmbus_read_word_data(client, page,
+                                           LTC2978_MFR_TEMPERATURE_MIN);
+                if (ret >= 0) {
+                        if (lin11_to_val(ret)
+                            < lin11_to_val(data->temp_min))
+                                data->temp_min = ret;
+                        ret = data->temp_min;
+                }
+                break;
+        case PMBUS_VIRT_READ_IOUT_MAX:
+        case PMBUS_VIRT_RESET_IOUT_HISTORY:
+        case PMBUS_VIRT_READ_TEMP2_MAX:
+        case PMBUS_VIRT_RESET_TEMP2_HISTORY:
+                ret = -ENXIO;
+                break;
+        default:
+                ret = ltc2978_read_word_data_common(client, page, reg);
+                break;
+        }
+        return ret;
+}
+
+static int ltc3880_read_word_data(struct i2c_client *client, int page, int reg)
+{
+        const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
+        struct ltc2978_data *data = to_ltc2978_data(info);
+        int ret;
+
+        switch (reg) {
+        case PMBUS_VIRT_READ_IOUT_MAX:
+                ret = pmbus_read_word_data(client, page, LTC3880_MFR_IOUT_PEAK);
+                if (ret >= 0) {
+                        if (lin11_to_val(ret)
+                            > lin11_to_val(data->iout_max[page]))
+                                data->iout_max[page] = ret;
+                        ret = data->iout_max[page];
+                }
+                break;
+        case PMBUS_VIRT_READ_TEMP2_MAX:
+                ret = pmbus_read_word_data(client, page,
+                                           LTC3880_MFR_TEMPERATURE2_PEAK);
+                if (ret >= 0) {
+                        if (lin11_to_val(ret)
+                            > lin11_to_val(data->temp2_max[page]))
+                                data->temp2_max[page] = ret;
+                        ret = data->temp2_max[page];
+                }
+                break;
+        case PMBUS_VIRT_READ_VIN_MIN:
+        case PMBUS_VIRT_READ_VOUT_MIN:
+        case PMBUS_VIRT_READ_TEMP_MIN:
+                ret = -ENXIO;
+                break;
+        case PMBUS_VIRT_RESET_IOUT_HISTORY:
+        case PMBUS_VIRT_RESET_TEMP2_HISTORY:
+                ret = 0;
+                break;
+        default:
+                ret = ltc2978_read_word_data_common(client, page, reg);
+                break;
+        }
+        return ret;
+}
+
+static int ltc2978_clear_peaks(struct i2c_client *client, int page,
+                               enum chips id)
+{
+        int ret;
+
+        if (id == ltc2978)
+                ret = pmbus_write_byte(client, page, PMBUS_CLEAR_FAULTS);
+        else
+                ret = pmbus_write_byte(client, 0, LTC3880_MFR_CLEAR_PEAKS);
+
+        return ret;
+}
+
+static int ltc2978_write_word_data(struct i2c_client *client, int page,
+                                    int reg, u16 word)
+{
+        const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
+        struct ltc2978_data *data = to_ltc2978_data(info);
+        int ret;
+
+        switch (reg) {
+        case PMBUS_VIRT_RESET_IOUT_HISTORY:
+                data->iout_max[page] = 0x7fff;
+                ret = ltc2978_clear_peaks(client, page, data->id);
+                break;
+        case PMBUS_VIRT_RESET_TEMP2_HISTORY:
+                data->temp2_max[page] = 0x7fff;
+                ret = ltc2978_clear_peaks(client, page, data->id);
+                break;
+        case PMBUS_VIRT_RESET_VOUT_HISTORY:
+                data->vout_min[page] = 0xffff;
+                data->vout_max[page] = 0;
+                ret = ltc2978_clear_peaks(client, page, data->id);
+                break;
+        case PMBUS_VIRT_RESET_VIN_HISTORY:
+                data->vin_min = 0x7bff;
+                data->vin_max = 0;
+                ret = ltc2978_clear_peaks(client, page, data->id);
+                break;
+        case PMBUS_VIRT_RESET_TEMP_HISTORY:
+                data->temp_min = 0x7bff;
+                data->temp_max = 0x7fff;
+                ret = ltc2978_clear_peaks(client, page, data->id);
+                break;
+        default:
+                ret = -ENODATA;
+                break;
+        }
+        return ret;
+}
+
+static const struct i2c_device_id ltc2978_id[] = {
+        {"ltc2978", ltc2978},
+        {"ltc3880", ltc3880},
+        {}
+};
+MODULE_DEVICE_TABLE(i2c, ltc2978_id);
+
+static int ltc2978_probe(struct i2c_client *client,
+                         const struct i2c_device_id *id)
+{
+        int chip_id, ret, i;
+        struct ltc2978_data *data;
+        struct pmbus_driver_info *info;
+
+        if (!i2c_check_functionality(client->adapter,
+                                     I2C_FUNC_SMBUS_READ_WORD_DATA))
+                return -ENODEV;
+
+        data = kzalloc(sizeof(struct ltc2978_data), GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+
+        chip_id = i2c_smbus_read_word_data(client, LTC2978_MFR_SPECIAL_ID);
+        if (chip_id < 0) {
+                ret = chip_id;
+                goto err_mem;
+        }
+
+        if (chip_id == LTC2978_ID_REV1 || chip_id == LTC2978_ID_REV2) {
+                data->id = ltc2978;
+        } else if ((chip_id & LTC3880_ID_MASK) == LTC3880_ID) {
+                data->id = ltc3880;
+        } else {
+                dev_err(&client->dev, "Unsupported chip ID 0x%x\n", chip_id);
+                ret = -ENODEV;
+                goto err_mem;
+        }
+        if (data->id != id->driver_data)
+                dev_warn(&client->dev,
+                         "Device mismatch: Configured %s, detected %s\n",
+                         id->name,
+                         ltc2978_id[data->id].name);
+
+        info = &data->info;
+        info->write_word_data = ltc2978_write_word_data;
+
+        data->vout_min[0] = 0xffff;
+        data->vin_min = 0x7bff;
+        data->temp_min = 0x7bff;
+        data->temp_max = 0x7fff;
+
+        switch (id->driver_data) {
+        case ltc2978:
+                info->read_word_data = ltc2978_read_word_data;
+                info->pages = 8;
+                info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT
+                  | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
+                  | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
+                for (i = 1; i < 8; i++) {
+                        info->func[i] = PMBUS_HAVE_VOUT
+                          | PMBUS_HAVE_STATUS_VOUT;
+                        data->vout_min[i] = 0xffff;
+                }
+                break;
+        case ltc3880:
+                info->read_word_data = ltc3880_read_word_data;
+                info->pages = 2;
+                info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN
+                  | PMBUS_HAVE_STATUS_INPUT
+                  | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
+                  | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
+                  | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP
+                  | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;
+                info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
+                  | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
+                  | PMBUS_HAVE_POUT
+                  | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
+                data->vout_min[1] = 0xffff;
+                break;
+        default:
+                ret = -ENODEV;
+                goto err_mem;
+        }
+
+        ret = pmbus_do_probe(client, id, info);
+        if (ret)
+                goto err_mem;
+        return 0;
+
+err_mem:
+        kfree(data);
+        return ret;
+}
+
+static int ltc2978_remove(struct i2c_client *client)
+{
+        const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
+        const struct ltc2978_data *data = to_ltc2978_data(info);
+
+        pmbus_do_remove(client);
+        kfree(data);
+        return 0;
+}
+
+/* This is the driver that will be inserted */
+static struct i2c_driver ltc2978_driver = {
+        .driver = {
+                   .name = "ltc2978",
+                   },
+        .probe = ltc2978_probe,
+        .remove = ltc2978_remove,
+        .id_table = ltc2978_id,
+};
+
+static int __init ltc2978_init(void)
+{
+        return i2c_add_driver(&ltc2978_driver);
+}
+
+static void __exit ltc2978_exit(void)
+{
+        i2c_del_driver(&ltc2978_driver);
+}
+
+MODULE_AUTHOR("Guenter Roeck");
+MODULE_DESCRIPTION("PMBus driver for LTC2978 and LTC3880");
+MODULE_LICENSE("GPL");
+module_init(ltc2978_init);
+module_exit(ltc2978_exit);
diff --git a/drivers/hwmon/pmbus/max16064.c b/drivers/hwmon/pmbus/max16064.c
index e50b296e8db..1d77cf4d2d4 100644
--- a/drivers/hwmon/pmbus/max16064.c
+++ b/drivers/hwmon/pmbus/max16064.c
@@ -105,7 +105,8 @@ static int max16064_probe(struct i2c_client *client,
 
 static int max16064_remove(struct i2c_client *client)
 {
-        return pmbus_do_remove(client);
+        pmbus_do_remove(client);
+        return 0;
 }
 
 static const struct i2c_device_id max16064_id[] = {
diff --git a/drivers/hwmon/pmbus/max34440.c b/drivers/hwmon/pmbus/max34440.c
index fda621d2e45..beaf5a8d9c4 100644
--- a/drivers/hwmon/pmbus/max34440.c
+++ b/drivers/hwmon/pmbus/max34440.c
@@ -93,12 +93,14 @@ static int max34440_write_word_data(struct i2c_client *client, int page,
 
 static int max34440_read_byte_data(struct i2c_client *client, int page, int reg)
 {
-        int ret;
+        int ret = 0;
         int mfg_status;
 
-        ret = pmbus_set_page(client, page);
-        if (ret < 0)
-                return ret;
+        if (page >= 0) {
+                ret = pmbus_set_page(client, page);
+                if (ret < 0)
+                        return ret;
+        }
 
         switch (reg) {
         case PMBUS_STATUS_IOUT:
@@ -224,7 +226,8 @@ static int max34440_probe(struct i2c_client *client,
 
 static int max34440_remove(struct i2c_client *client)
 {
-        return pmbus_do_remove(client);
+        pmbus_do_remove(client);
+        return 0;
 }
 
 static const struct i2c_device_id max34440_id[] = {
diff --git a/drivers/hwmon/pmbus/max8688.c b/drivers/hwmon/pmbus/max8688.c
index c3e72f1a3cf..e2b74bb399b 100644
--- a/drivers/hwmon/pmbus/max8688.c
+++ b/drivers/hwmon/pmbus/max8688.c
@@ -45,7 +45,7 @@ static int max8688_read_word_data(struct i2c_client *client, int page, int reg)
         int ret;
 
         if (page)
-                return -EINVAL;
+                return -ENXIO;
 
         switch (reg) {
         case PMBUS_VIRT_READ_VOUT_MAX:
@@ -101,8 +101,8 @@ static int max8688_read_byte_data(struct i2c_client *client, int page, int reg)
         int ret = 0;
         int mfg_status;
 
-        if (page)
-                return -EINVAL;
+        if (page > 0)
+                return -ENXIO;
 
         switch (reg) {
         case PMBUS_STATUS_VOUT:
@@ -182,7 +182,8 @@ static int max8688_probe(struct i2c_client *client,
 
 static int max8688_remove(struct i2c_client *client)
 {
-        return pmbus_do_remove(client);
+        pmbus_do_remove(client);
+        return 0;
 }
 
 static const struct i2c_device_id max8688_id[] = {
diff --git a/drivers/hwmon/pmbus/pmbus.c b/drivers/hwmon/pmbus/pmbus.c
index 73de9f1f319..995e873197e 100644
--- a/drivers/hwmon/pmbus/pmbus.c
+++ b/drivers/hwmon/pmbus/pmbus.c
@@ -187,13 +187,12 @@ out:
 
 static int pmbus_remove(struct i2c_client *client)
 {
-        int ret;
         const struct pmbus_driver_info *info;
 
         info = pmbus_get_driver_info(client);
-        ret = pmbus_do_remove(client);
+        pmbus_do_remove(client);
         kfree(info);
-        return ret;
+        return 0;
 }
 
 /*
@@ -205,10 +204,13 @@ static const struct i2c_device_id pmbus_id[] = {
         {"bmr451", 1},
         {"bmr453", 1},
         {"bmr454", 1},
-        {"ltc2978", 8},
         {"ncp4200", 1},
         {"ncp4208", 1},
+        {"pdt003", 1},
+        {"pdt006", 1},
+        {"pdt012", 1},
         {"pmbus", 0},
+        {"udt020", 1},
         {}
 };
 
diff --git a/drivers/hwmon/pmbus/pmbus.h b/drivers/hwmon/pmbus/pmbus.h
index a6ae20ffef6..5d31d1c2c0f 100644
--- a/drivers/hwmon/pmbus/pmbus.h
+++ b/drivers/hwmon/pmbus/pmbus.h
@@ -134,8 +134,16 @@
  * Semantics:
  * Virtual registers are all word size.
  * READ registers are read-only; writes are either ignored or return an error.
- * RESET registers are read/write. Reading returns zero (used for detection),
- * writing any value causes the associated history to be reset.
+ * RESET registers are read/write. Reading reset registers returns zero
+ * (used for detection), writing any value causes the associated history to be
+ * reset.
+ * Virtual registers have to be handled in device specific driver code. Chip
+ * driver code returns non-negative register values if a virtual register is
+ * supported, or a negative error code if not. The chip driver may return
+ * -ENODATA or any other error code in this case, though an error code other
+ * than -ENODATA is handled more efficiently and thus preferred. Either case,
+ * the calling PMBus core code will abort if the chip driver returns an error
+ * code when reading or writing virtual registers.
  */
 #define PMBUS_VIRT_BASE                 0x100
 #define PMBUS_VIRT_READ_TEMP_MIN        (PMBUS_VIRT_BASE + 0)
@@ -160,6 +168,9 @@
 #define PMBUS_VIRT_READ_IOUT_MIN        (PMBUS_VIRT_BASE + 19)
 #define PMBUS_VIRT_READ_IOUT_MAX        (PMBUS_VIRT_BASE + 20)
 #define PMBUS_VIRT_RESET_IOUT_HISTORY   (PMBUS_VIRT_BASE + 21)
+#define PMBUS_VIRT_READ_TEMP2_MIN       (PMBUS_VIRT_BASE + 22)
+#define PMBUS_VIRT_READ_TEMP2_MAX       (PMBUS_VIRT_BASE + 23)
+#define PMBUS_VIRT_RESET_TEMP2_HISTORY  (PMBUS_VIRT_BASE + 24)
 
 /*
  * CAPABILITY
@@ -320,6 +331,12 @@ struct pmbus_driver_info {
          * The following functions map manufacturing specific register values
          * to PMBus standard register values. Specify only if mapping is
          * necessary.
+         * Functions return the register value (read) or zero (write) if
+         * successful. A return value of -ENODATA indicates that there is no
+         * manufacturer specific register, but that a standard PMBus register
+         * may exist. Any other negative return value indicates that the
+         * register does not exist, and that no attempt should be made to read
+         * the standard register.
          */
         int (*read_byte_data)(struct i2c_client *client, int page, int reg);
         int (*read_word_data)(struct i2c_client *client, int page, int reg);
@@ -347,7 +364,7 @@ bool pmbus_check_byte_register(struct i2c_client *client, int page, int reg);
 bool pmbus_check_word_register(struct i2c_client *client, int page, int reg);
 int pmbus_do_probe(struct i2c_client *client, const struct i2c_device_id *id,
                    struct pmbus_driver_info *info);
-int pmbus_do_remove(struct i2c_client *client);
+void pmbus_do_remove(struct i2c_client *client);
 const struct pmbus_driver_info *pmbus_get_driver_info(struct i2c_client
                                                       *client);
 
diff --git a/drivers/hwmon/pmbus/pmbus_core.c b/drivers/hwmon/pmbus/pmbus_core.c
index 397fc59b568..00460d8d842 100644
--- a/drivers/hwmon/pmbus/pmbus_core.c
+++ b/drivers/hwmon/pmbus/pmbus_core.c
@@ -160,7 +160,7 @@ int pmbus_set_page(struct i2c_client *client, u8 page)
                 rv = i2c_smbus_write_byte_data(client, PMBUS_PAGE, page);
                 newpage = i2c_smbus_read_byte_data(client, PMBUS_PAGE);
                 if (newpage != page)
-                        rv = -EINVAL;
+                        rv = -EIO;
                 else
                         data->currpage = page;
         }
@@ -229,7 +229,7 @@ static int _pmbus_write_word_data(struct i2c_client *client, int page, int reg,
                         return status;
         }
         if (reg >= PMBUS_VIRT_BASE)
-                return -EINVAL;
+                return -ENXIO;
         return pmbus_write_word_data(client, page, reg, word);
 }
 
@@ -261,7 +261,7 @@ static int _pmbus_read_word_data(struct i2c_client *client, int page, int reg)
                         return status;
         }
         if (reg >= PMBUS_VIRT_BASE)
-                return -EINVAL;
+                return -ENXIO;
         return pmbus_read_word_data(client, page, reg);
 }
 
@@ -316,11 +316,11 @@ static int pmbus_check_status_cml(struct i2c_client *client)
 {
         int status, status2;
 
-        status = pmbus_read_byte_data(client, -1, PMBUS_STATUS_BYTE);
+        status = _pmbus_read_byte_data(client, -1, PMBUS_STATUS_BYTE);
         if (status < 0 || (status & PB_STATUS_CML)) {
-                status2 = pmbus_read_byte_data(client, -1, PMBUS_STATUS_CML);
+                status2 = _pmbus_read_byte_data(client, -1, PMBUS_STATUS_CML);
                 if (status2 < 0 || (status2 & PB_CML_FAULT_INVALID_COMMAND))
-                        return -EINVAL;
+                        return -EIO;
         }
         return 0;
 }
@@ -371,8 +371,8 @@ static struct pmbus_data *pmbus_update_device(struct device *dev)
 
                 for (i = 0; i < info->pages; i++)
                         data->status[PB_STATUS_BASE + i]
-                            = pmbus_read_byte_data(client, i,
-                                                   PMBUS_STATUS_BYTE);
+                            = _pmbus_read_byte_data(client, i,
+                                                    PMBUS_STATUS_BYTE);
                 for (i = 0; i < info->pages; i++) {
                         if (!(info->func[i] & PMBUS_HAVE_STATUS_VOUT))
                                 continue;
@@ -445,13 +445,8 @@ static long pmbus_reg2data_linear(struct pmbus_data *data,
                 exponent = data->exponent;
                 mantissa = (u16) sensor->data;
         } else {                                /* LINEAR11 */
-                exponent = (sensor->data >> 11) & 0x001f;
-                mantissa = sensor->data & 0x07ff;
-
-                if (exponent > 0x0f)
-                        exponent |= 0xffe0;     /* sign extend exponent */
-                if (mantissa > 0x03ff)
-                        mantissa |= 0xfffff800; /* sign extend mantissa */
+                exponent = ((s16)sensor->data) >> 11;
+                mantissa = ((s16)((sensor->data & 0x7ff) << 5)) >> 5;
         }
 
         val = mantissa;
@@ -1401,7 +1396,42 @@ static const struct pmbus_limit_attr temp_limit_attrs[] = {
         }
 };
 
-static const struct pmbus_limit_attr temp_limit_attrs23[] = {
+static const struct pmbus_limit_attr temp_limit_attrs2[] = {
+        {
+                .reg = PMBUS_UT_WARN_LIMIT,
+                .low = true,
+                .attr = "min",
+                .alarm = "min_alarm",
+                .sbit = PB_TEMP_UT_WARNING,
+        }, {
+                .reg = PMBUS_UT_FAULT_LIMIT,
+                .low = true,
+                .attr = "lcrit",
+                .alarm = "lcrit_alarm",
+                .sbit = PB_TEMP_UT_FAULT,
+        }, {
+                .reg = PMBUS_OT_WARN_LIMIT,
+                .attr = "max",
+                .alarm = "max_alarm",
+                .sbit = PB_TEMP_OT_WARNING,
+        }, {
+                .reg = PMBUS_OT_FAULT_LIMIT,
+                .attr = "crit",
+                .alarm = "crit_alarm",
+                .sbit = PB_TEMP_OT_FAULT,
+        }, {
+                .reg = PMBUS_VIRT_READ_TEMP2_MIN,
+                .attr = "lowest",
+        }, {
+                .reg = PMBUS_VIRT_READ_TEMP2_MAX,
+                .attr = "highest",
+        }, {
+                .reg = PMBUS_VIRT_RESET_TEMP2_HISTORY,
+                .attr = "reset_history",
+        }
+};
+
+static const struct pmbus_limit_attr temp_limit_attrs3[] = {
         {
                 .reg = PMBUS_UT_WARN_LIMIT,
                 .low = true,
@@ -1450,8 +1480,8 @@ static const struct pmbus_sensor_attr temp_attributes[] = {
                 .sfunc = PMBUS_HAVE_STATUS_TEMP,
                 .sbase = PB_STATUS_TEMP_BASE,
                 .gbit = PB_STATUS_TEMPERATURE,
-                .limit = temp_limit_attrs23,
-                .nlimit = ARRAY_SIZE(temp_limit_attrs23),
+                .limit = temp_limit_attrs2,
+                .nlimit = ARRAY_SIZE(temp_limit_attrs2),
         }, {
                 .reg = PMBUS_READ_TEMPERATURE_3,
                 .class = PSC_TEMPERATURE,
@@ -1462,8 +1492,8 @@ static const struct pmbus_sensor_attr temp_attributes[] = {
                 .sfunc = PMBUS_HAVE_STATUS_TEMP,
                 .sbase = PB_STATUS_TEMP_BASE,
                 .gbit = PB_STATUS_TEMPERATURE,
-                .limit = temp_limit_attrs23,
-                .nlimit = ARRAY_SIZE(temp_limit_attrs23),
+                .limit = temp_limit_attrs3,
+                .nlimit = ARRAY_SIZE(temp_limit_attrs3),
         }
 };
 
@@ -1593,10 +1623,10 @@ static void pmbus_find_attributes(struct i2c_client *client,
 static int pmbus_identify_common(struct i2c_client *client,
                                  struct pmbus_data *data)
 {
-        int vout_mode = -1, exponent;
+        int vout_mode = -1;
 
         if (pmbus_check_byte_register(client, 0, PMBUS_VOUT_MODE))
-                vout_mode = pmbus_read_byte_data(client, 0, PMBUS_VOUT_MODE);
+                vout_mode = _pmbus_read_byte_data(client, 0, PMBUS_VOUT_MODE);
         if (vout_mode >= 0 && vout_mode != 0xff) {
                 /*
                  * Not all chips support the VOUT_MODE command,
@@ -1607,11 +1637,7 @@ static int pmbus_identify_common(struct i2c_client *client,
                         if (data->info->format[PSC_VOLTAGE_OUT] != linear)
                                 return -ENODEV;
 
-                        exponent = vout_mode & 0x1f;
-                        /* and sign-extend it */
-                        if (exponent & 0x10)
-                                exponent |= ~0x1f;
-                        data->exponent = exponent;
+                        data->exponent = ((s8)(vout_mode << 3)) >> 3;
                         break;
                 case 1: /* VID mode         */
                         if (data->info->format[PSC_VOLTAGE_OUT] != vid)
@@ -1682,7 +1708,7 @@ int pmbus_do_probe(struct i2c_client *client, const struct i2c_device_id *id,
         if (info->pages <= 0 || info->pages > PMBUS_PAGES) {
                 dev_err(&client->dev, "Bad number of PMBus pages: %d\n",
                         info->pages);
-                ret = -EINVAL;
+                ret = -ENODEV;
                 goto out_data;
         }
 
@@ -1764,7 +1790,7 @@ out_data:
 }
 EXPORT_SYMBOL_GPL(pmbus_do_probe);
 
-int pmbus_do_remove(struct i2c_client *client)
+void pmbus_do_remove(struct i2c_client *client)
 {
         struct pmbus_data *data = i2c_get_clientdata(client);
         hwmon_device_unregister(data->hwmon_dev);
@@ -1774,7 +1800,6 @@ int pmbus_do_remove(struct i2c_client *client)
         kfree(data->booleans);
         kfree(data->sensors);
         kfree(data);
-        return 0;
 }
 EXPORT_SYMBOL_GPL(pmbus_do_remove);
 
diff --git a/drivers/hwmon/pmbus/ucd9000.c b/drivers/hwmon/pmbus/ucd9000.c
index d0ddb60155c..4ff6cf289f8 100644
--- a/drivers/hwmon/pmbus/ucd9000.c
+++ b/drivers/hwmon/pmbus/ucd9000.c
@@ -74,8 +74,8 @@ static int ucd9000_read_byte_data(struct i2c_client *client, int page, int reg)
 
         switch (reg) {
         case PMBUS_FAN_CONFIG_12:
-                if (page)
-                        return -EINVAL;
+                if (page > 0)
+                        return -ENXIO;
 
                 ret = ucd9000_get_fan_config(client, 0);
                 if (ret < 0)
@@ -88,8 +88,8 @@ static int ucd9000_read_byte_data(struct i2c_client *client, int page, int reg)
                 ret = fan_config;
                 break;
         case PMBUS_FAN_CONFIG_34:
-                if (page)
-                        return -EINVAL;
+                if (page > 0)
+                        return -ENXIO;
 
                 ret = ucd9000_get_fan_config(client, 2);
                 if (ret < 0)
@@ -239,13 +239,12 @@ out:
 
 static int ucd9000_remove(struct i2c_client *client)
 {
-        int ret;
         struct ucd9000_data *data;
 
         data = to_ucd9000_data(pmbus_get_driver_info(client));
-        ret = pmbus_do_remove(client);
+        pmbus_do_remove(client);
         kfree(data);
-        return ret;
+        return 0;
 }
 
 
diff --git a/drivers/hwmon/pmbus/ucd9200.c b/drivers/hwmon/pmbus/ucd9200.c
index c65e9da707c..6e1c1a80ab8 100644
--- a/drivers/hwmon/pmbus/ucd9200.c
+++ b/drivers/hwmon/pmbus/ucd9200.c
@@ -171,13 +171,12 @@ out:
 
 static int ucd9200_remove(struct i2c_client *client)
 {
-        int ret;
         const struct pmbus_driver_info *info;
 
         info = pmbus_get_driver_info(client);
-        ret = pmbus_do_remove(client);
+        pmbus_do_remove(client);
         kfree(info);
-        return ret;
+        return 0;
 }
 
 
diff --git a/drivers/hwmon/pmbus/zl6100.c b/drivers/hwmon/pmbus/zl6100.c
new file mode 100644
index 00000000000..2bc980006f8
--- /dev/null
+++ b/drivers/hwmon/pmbus/zl6100.c
@@ -0,0 +1,256 @@
+/*
+ * Hardware monitoring driver for ZL6100 and compatibles
+ *
+ * Copyright (c) 2011 Ericsson AB.
+ *
+ * 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/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/err.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/ktime.h>
+#include <linux/delay.h>
+#include "pmbus.h"
+
+enum chips { zl2004, zl2006, zl2008, zl2105, zl2106, zl6100, zl6105 };
+
+struct zl6100_data {
+        int id;
+        ktime_t access;         /* chip access time */
+        struct pmbus_driver_info info;
+};
+
+#define to_zl6100_data(x)  container_of(x, struct zl6100_data, info)
+
+#define ZL6100_DEVICE_ID                0xe4
+
+#define ZL6100_WAIT_TIME                1000    /* uS   */
+
+static ushort delay = ZL6100_WAIT_TIME;
+module_param(delay, ushort, 0644);
+MODULE_PARM_DESC(delay, "Delay between chip accesses in uS");
+
+/* Some chips need a delay between accesses */
+static inline void zl6100_wait(const struct zl6100_data *data)
+{
+        if (delay) {
+                s64 delta = ktime_us_delta(ktime_get(), data->access);
+                if (delta < delay)
+                        udelay(delay - delta);
+        }
+}
+
+static int zl6100_read_word_data(struct i2c_client *client, int page, int reg)
+{
+        const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
+        struct zl6100_data *data = to_zl6100_data(info);
+        int ret;
+
+        if (page || reg >= PMBUS_VIRT_BASE)
+                return -ENXIO;
+
+        zl6100_wait(data);
+        ret = pmbus_read_word_data(client, page, reg);
+        data->access = ktime_get();
+
+        return ret;
+}
+
+static int zl6100_read_byte_data(struct i2c_client *client, int page, int reg)
+{
+        const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
+        struct zl6100_data *data = to_zl6100_data(info);
+        int ret;
+
+        if (page > 0)
+                return -ENXIO;
+
+        zl6100_wait(data);
+        ret = pmbus_read_byte_data(client, page, reg);
+        data->access = ktime_get();
+
+        return ret;
+}
+
+static int zl6100_write_word_data(struct i2c_client *client, int page, int reg,
+                                  u16 word)
+{
+        const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
+        struct zl6100_data *data = to_zl6100_data(info);
+        int ret;
+
+        if (page || reg >= PMBUS_VIRT_BASE)
+                return -ENXIO;
+
+        zl6100_wait(data);
+        ret = pmbus_write_word_data(client, page, reg, word);
+        data->access = ktime_get();
+
+        return ret;
+}
+
+static int zl6100_write_byte(struct i2c_client *client, int page, u8 value)
+{
+        const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
+        struct zl6100_data *data = to_zl6100_data(info);
+        int ret;
+
+        if (page > 0)
+                return -ENXIO;
+
+        zl6100_wait(data);
+        ret = pmbus_write_byte(client, page, value);
+        data->access = ktime_get();
+
+        return ret;
+}
+
+static const struct i2c_device_id zl6100_id[] = {
+        {"zl2004", zl2004},
+        {"zl2006", zl2006},
+        {"zl2008", zl2008},
+        {"zl2105", zl2105},
+        {"zl2106", zl2106},
+        {"zl6100", zl6100},
+        {"zl6105", zl6105},
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, zl6100_id);
+
+static int zl6100_probe(struct i2c_client *client,
+                        const struct i2c_device_id *id)
+{
+        int ret;
+        struct zl6100_data *data;
+        struct pmbus_driver_info *info;
+        u8 device_id[I2C_SMBUS_BLOCK_MAX + 1];
+        const struct i2c_device_id *mid;
+
+        if (!i2c_check_functionality(client->adapter,
+                                     I2C_FUNC_SMBUS_READ_BYTE_DATA
+                                     | I2C_FUNC_SMBUS_READ_BLOCK_DATA))
+                return -ENODEV;
+
+        ret = i2c_smbus_read_block_data(client, ZL6100_DEVICE_ID,
+                                        device_id);
+        if (ret < 0) {
+                dev_err(&client->dev, "Failed to read device ID\n");
+                return ret;
+        }
+        device_id[ret] = '\0';
+        dev_info(&client->dev, "Device ID %s\n", device_id);
+
+        mid = NULL;
+        for (mid = zl6100_id; mid->name[0]; mid++) {
+                if (!strncasecmp(mid->name, device_id, strlen(mid->name)))
+                        break;
+        }
+        if (!mid->name[0]) {
+                dev_err(&client->dev, "Unsupported device\n");
+                return -ENODEV;
+        }
+        if (id->driver_data != mid->driver_data)
+                dev_notice(&client->dev,
+                           "Device mismatch: Configured %s, detected %s\n",
+                           id->name, mid->name);
+
+        data = kzalloc(sizeof(struct zl6100_data), GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+
+        data->id = mid->driver_data;
+
+        /*
+         * ZL2008, ZL2105, and ZL6100 are known to require a wait time
+         * between I2C accesses. ZL2004 and ZL6105 are known to be safe.
+         *
+         * Only clear the wait time for chips known to be safe. The wait time
+         * can be cleared later for additional chips if tests show that it
+         * is not needed (in other words, better be safe than sorry).
+         */
+        if (data->id == zl2004 || data->id == zl6105)
+                delay = 0;
+
+        /*
+         * Since there was a direct I2C device access above, wait before
+         * accessing the chip again.
+         * Set the timestamp, wait, then set it again. This should provide
+         * enough buffer time to be safe.
+         */
+        data->access = ktime_get();
+        zl6100_wait(data);
+        data->access = ktime_get();
+
+        info = &data->info;
+
+        info->pages = 1;
+        info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT
+          | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
+          | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
+          | PMBUS_HAVE_TEMP | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;
+
+        info->read_word_data = zl6100_read_word_data;
+        info->read_byte_data = zl6100_read_byte_data;
+        info->write_word_data = zl6100_write_word_data;
+        info->write_byte = zl6100_write_byte;
+
+        ret = pmbus_do_probe(client, mid, info);
+        if (ret)
+                goto err_mem;
+        return 0;
+
+err_mem:
+        kfree(data);
+        return ret;
+}
+
+static int zl6100_remove(struct i2c_client *client)
+{
+        const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
+        const struct zl6100_data *data = to_zl6100_data(info);
+
+        pmbus_do_remove(client);
+        kfree(data);
+        return 0;
+}
+
+static struct i2c_driver zl6100_driver = {
+        .driver = {
+                   .name = "zl6100",
+                   },
+        .probe = zl6100_probe,
+        .remove = zl6100_remove,
+        .id_table = zl6100_id,
+};
+
+static int __init zl6100_init(void)
+{
+        return i2c_add_driver(&zl6100_driver);
+}
+
+static void __exit zl6100_exit(void)
+{
+        i2c_del_driver(&zl6100_driver);
+}
+
+MODULE_AUTHOR("Guenter Roeck");
+MODULE_DESCRIPTION("PMBus driver for ZL6100 and compatibles");
+MODULE_LICENSE("GPL");
+module_init(zl6100_init);
+module_exit(zl6100_exit);