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

* 'hwmon-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jdelvare/staging: (41 commits) hwmon: (adt7475) Add VID support for the ADT7476 hwmon: (adt7475) Add an entry in MAINTAINERS hwmon: (adt7475) Add support for the ADT7476 hwmon: (adt7475) Voltage attenuators can be bypassed hwmon: (adt7475) Print device information on probe hwmon: (adt7475) Handle alternative pin functions hwmon: (adt7475) Move sysfs files removal to a separate function hwmon: (adt7475) Add support for the ADT7490 hwmon: (adt7475) Improve device detection hwmon: (adt7475) Add missing static marker hwmon: (adt7475) Rework voltage inputs handling hwmon: (adt7475) Implement pwm_use_point2_pwm_at_crit hwmon: (adt7475) New documentation hwmon: (adt7475) Add support for the ADT7473 hwmon: (f71882fg) Add support for the f71889fg (version 2) hwmon: (f71882fg) Fix sysfs file removal hwmon: (f71882fg) Cleanup sysfs attr creation 2/2 hwmon: (f71882fg) Cleanup sysfs attr creation 1/2 hwmon: (thmc50) Stop using I2C_CLIENT_MODULE_PARM hwmon: Add Freescale MC13783 ADC driver ...
author: Linus Torvalds <torvalds@linux-foundation.org> 2009-12-09 22:53:11 -0500
committer: Linus Torvalds <torvalds@linux-foundation.org> 2009-12-09 22:53:11 -0500
commit: f71eaf68406cfee91b6a96bcdf7ce33dc78829c5 (patch)
tree: 92a1663ae15d521f25849d28ebb4dfad10567892 /drivers
parent: 78f1ae193d1662c22cfebb916e788e1ca896c0fe (diff)
parent: 54fe4671aa5853ca88da72d67e969a3d8de6dcf6 (diff)
49 files changed, 2082 insertions, 1650 deletions
diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
index 700e93adeb33..9e640c62ebd9 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -191,21 +191,27 @@ config SENSORS_ADT7470
          will be called adt7470.
 config SENSORS_ADT7473
-        tristate "Analog Devices ADT7473"
+        tristate "Analog Devices ADT7473 (DEPRECATED)"
        depends on I2C && EXPERIMENTAL
+        select SENSORS_ADT7475
        help
          If you say yes here you get support for the Analog Devices
          ADT7473 temperature monitoring chips.
+          This driver is deprecated, you should use the adt7475 driver
+          instead.
          This driver can also be built as a module. If so, the module
          will be called adt7473.
 config SENSORS_ADT7475
-        tristate "Analog Devices ADT7475"
+        tristate "Analog Devices ADT7473, ADT7475, ADT7476 and ADT7490"
        depends on I2C && EXPERIMENTAL
+        select HWMON_VID
        help
          If you say yes here you get support for the Analog Devices
-          ADT7475 hardware monitoring chips.
+          ADT7473, ADT7475, ADT7476 and ADT7490 hardware monitoring
+          chips.
          This driver can also be build as a module.  If so, the module
          will be called adt7475.
@@ -305,12 +311,12 @@ config SENSORS_F71805F
          will be called f71805f.
 config SENSORS_F71882FG
-        tristate "Fintek F71858FG, F71862FG, F71882FG and F8000"
+        tristate "Fintek F71858FG, F71862FG, F71882FG, F71889FG and F8000"
        depends on EXPERIMENTAL
        help
          If you say yes here you get support for hardware monitoring
-          features of the Fintek F71858FG, F71862FG/71863FG, F71882FG/F71883FG
+          features of the Fintek F71858FG, F71862FG/71863FG, F71882FG/F71883FG,
-          and F8000 Super-I/O chips.
+          F71889FG and F8000 Super-I/O chips.
          This driver can also be built as a module.  If so, the module
          will be called f71882fg.
@@ -442,6 +448,15 @@ config SENSORS_LM70
          This driver can also be built as a module.  If so, the module
          will be called lm70.
+config SENSORS_LM73
+        tristate "National Semiconductor LM73"
+        depends on I2C
+        help
+          If you say yes here you get support for National Semiconductor LM73
+          sensor chips.
+          This driver can also be built as a module.  If so, the module
+          will be called lm73.
 config SENSORS_LM75
        tristate "National Semiconductor LM75 and compatibles"
        depends on I2C
@@ -841,7 +856,7 @@ config SENSORS_W83781D
 config SENSORS_W83791D
        tristate "Winbond W83791D"
-        depends on I2C && EXPERIMENTAL
+        depends on I2C
        select HWMON_VID
        help
          If you say yes here you get support for the Winbond W83791D chip.
@@ -1008,6 +1023,12 @@ config SENSORS_APPLESMC
          Say Y here if you have an applicable laptop and want to experience
          the awesome power of applesmc.
+config SENSORS_MC13783_ADC
+        tristate "Freescale MC13783 ADC"
+        depends on MFD_MC13783
+        help
+          Support for the A/D converter on MC13783 PMIC.
 if ACPI
 comment "ACPI drivers"
diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
index 9f46cb019cc6..33c2ee105284 100644
--- a/drivers/hwmon/Makefile
+++ b/drivers/hwmon/Makefile
@@ -57,6 +57,7 @@ obj-$(CONFIG_SENSORS_LIS3LV02D) += lis3lv02d.o hp_accel.o
 obj-$(CONFIG_SENSORS_LIS3_SPI)  += lis3lv02d.o lis3lv02d_spi.o
 obj-$(CONFIG_SENSORS_LM63)      += lm63.o
 obj-$(CONFIG_SENSORS_LM70)      += lm70.o
+obj-$(CONFIG_SENSORS_LM73)      += lm73.o
 obj-$(CONFIG_SENSORS_LM75)      += lm75.o
 obj-$(CONFIG_SENSORS_LM77)      += lm77.o
 obj-$(CONFIG_SENSORS_LM78)      += lm78.o
@@ -73,6 +74,7 @@ obj-$(CONFIG_SENSORS_LTC4245)	+= ltc4245.o
 obj-$(CONFIG_SENSORS_MAX1111)   += max1111.o
 obj-$(CONFIG_SENSORS_MAX1619)   += max1619.o
 obj-$(CONFIG_SENSORS_MAX6650)   += max6650.o
+obj-$(CONFIG_SENSORS_MC13783_ADC)+= mc13783-adc.o
 obj-$(CONFIG_SENSORS_PC87360)   += pc87360.o
 obj-$(CONFIG_SENSORS_PC87427)   += pc87427.o
 obj-$(CONFIG_SENSORS_PCF8591)   += pcf8591.o
diff --git a/drivers/hwmon/adm1021.c b/drivers/hwmon/adm1021.c
index afc594318125..33acf29531af 100644
--- a/drivers/hwmon/adm1021.c
+++ b/drivers/hwmon/adm1021.c
@@ -288,9 +288,8 @@ static int adm1021_detect(struct i2c_client *client, int kind,
                          struct i2c_board_info *info)
 {
        struct i2c_adapter *adapter = client->adapter;
-        int i;
+        const char *type_name;
-        const char *type_name = "";
+        int conv_rate, status, config, man_id, dev_id;
-        int conv_rate, status, config;
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
                pr_debug("adm1021: detect failed, "
@@ -303,62 +302,37 @@ static int adm1021_detect(struct i2c_client *client, int kind,
                                             ADM1021_REG_CONV_RATE_R);
        config = i2c_smbus_read_byte_data(client, ADM1021_REG_CONFIG_R);
-        /* Now, we do the remaining detection. */
+        /* Check unused bits */
-        if (kind < 0) {
+        if ((status & 0x03) || (config & 0x3F) || (conv_rate & 0xF8)) {
-                if ((status & 0x03) != 0x00 || (config & 0x3F) != 0x00
+                pr_debug("adm1021: detect failed, chip not detected!\n");
-                    || (conv_rate & 0xF8) != 0x00) {
+                return -ENODEV;
-                        pr_debug("adm1021: detect failed, "
-                                 "chip not detected!\n");
-                        return -ENODEV;
-                }
        }
        /* Determine the chip type. */
-        if (kind <= 0) {
+        man_id = i2c_smbus_read_byte_data(client, ADM1021_REG_MAN_ID);
-                i = i2c_smbus_read_byte_data(client, ADM1021_REG_MAN_ID);
+        dev_id = i2c_smbus_read_byte_data(client, ADM1021_REG_DEV_ID);
-                if (i == 0x41)
-                        if ((i2c_smbus_read_byte_data(client,
-                                        ADM1021_REG_DEV_ID) & 0xF0) == 0x30)
-                                kind = adm1023;
-                        else
-                                kind = adm1021;
-                else if (i == 0x49)
-                        kind = thmc10;
-                else if (i == 0x23)
-                        kind = gl523sm;
-                else if ((i == 0x4d) &&
-                         (i2c_smbus_read_byte_data(client,
-                                                   ADM1021_REG_DEV_ID) == 0x01))
-                        kind = max1617a;
-                else if (i == 0x54)
-                        kind = mc1066;
-                /* LM84 Mfr ID in a different place, and it has more unused bits */
-                else if (conv_rate == 0x00
-                         && (kind == 0 /* skip extra detection */
-                             || ((config & 0x7F) == 0x00
-                                 && (status & 0xAB) == 0x00)))
-                        kind = lm84;
-                else
-                        kind = max1617;
-        }
-        if (kind == max1617) {
+        if (man_id == 0x4d && dev_id == 0x01)
-                type_name = "max1617";
-        } else if (kind == max1617a) {
                type_name = "max1617a";
-        } else if (kind == adm1021) {
+        else if (man_id == 0x41) {
-                type_name = "adm1021";
+                if ((dev_id & 0xF0) == 0x30)
-        } else if (kind == adm1023) {
+                        type_name = "adm1023";
-                type_name = "adm1023";
+                else
-        } else if (kind == thmc10) {
+                        type_name = "adm1021";
+        } else if (man_id == 0x49)
                type_name = "thmc10";
-        } else if (kind == lm84) {
+        else if (man_id == 0x23)
-                type_name = "lm84";
-        } else if (kind == gl523sm) {
                type_name = "gl523sm";
-        } else if (kind == mc1066) {
+        else if (man_id == 0x54)
                type_name = "mc1066";
-        }
+        /* LM84 Mfr ID in a different place, and it has more unused bits */
+        else if (conv_rate == 0x00
+                 && (config & 0x7F) == 0x00
+                 && (status & 0xAB) == 0x00)
+                type_name = "lm84";
+        else
+                type_name = "max1617";
        pr_debug("adm1021: Detected chip %s at adapter %d, address 0x%02x.\n",
                 type_name, i2c_adapter_id(adapter), client->addr);
        strlcpy(info->type, type_name, I2C_NAME_SIZE);
diff --git a/drivers/hwmon/adm1025.c b/drivers/hwmon/adm1025.c
index 4db04d603ec9..db6ac2b04f6f 100644
--- a/drivers/hwmon/adm1025.c
+++ b/drivers/hwmon/adm1025.c
@@ -2,7 +2,7 @@
 * adm1025.c
 *
 * Copyright (C) 2000       Chen-Yuan Wu <gwu@esoft.com>
- * Copyright (C) 2003-2008  Jean Delvare <khali@linux-fr.org>
+ * Copyright (C) 2003-2009  Jean Delvare <khali@linux-fr.org>
 *
 * The ADM1025 is a sensor chip made by Analog Devices. It reports up to 6
 * voltages (including its own power source) and up to two temperatures
@@ -413,67 +413,34 @@ static int adm1025_detect(struct i2c_client *client, int kind,
                          struct i2c_board_info *info)
 {
        struct i2c_adapter *adapter = client->adapter;
-        const char *name = "";
+        const char *name;
-        u8 config;
+        u8 man_id, chip_id;
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                return -ENODEV;
-        /*
+        /* Check for unused bits */
-         * Now we do the remaining detection. A negative kind means that
+        if ((i2c_smbus_read_byte_data(client, ADM1025_REG_CONFIG) & 0x80)
-         * the driver was loaded with no force parameter (default), so we
+         || (i2c_smbus_read_byte_data(client, ADM1025_REG_STATUS1) & 0xC0)
-         * must both detect and identify the chip. A zero kind means that
+         || (i2c_smbus_read_byte_data(client, ADM1025_REG_STATUS2) & 0xBC)) {
-         * the driver was loaded with the force parameter, the detection
+                dev_dbg(&adapter->dev, "ADM1025 detection failed at 0x%02x\n",
-         * step shall be skipped. A positive kind means that the driver
+                        client->addr);
-         * was loaded with the force parameter and a given kind of chip is
+                return -ENODEV;
-         * requested, so both the detection and the identification steps
-         * are skipped.
-         */
-        config = i2c_smbus_read_byte_data(client, ADM1025_REG_CONFIG);
-        if (kind < 0) { /* detection */
-                if ((config & 0x80) != 0x00
-                 || (i2c_smbus_read_byte_data(client,
-                     ADM1025_REG_STATUS1) & 0xC0) != 0x00
-                 || (i2c_smbus_read_byte_data(client,
-                     ADM1025_REG_STATUS2) & 0xBC) != 0x00) {
-                        dev_dbg(&adapter->dev,
-                                "ADM1025 detection failed at 0x%02x.\n",
-                                client->addr);
-                        return -ENODEV;
-                }
        }
-        if (kind <= 0) { /* identification */
+        /* Identification */
-                u8 man_id, chip_id;
+        chip_id = i2c_smbus_read_byte_data(client, ADM1025_REG_CHIP_ID);
+        if ((chip_id & 0xF0) != 0x20)
-                man_id = i2c_smbus_read_byte_data(client, ADM1025_REG_MAN_ID);
+                return -ENODEV;
-                chip_id = i2c_smbus_read_byte_data(client, ADM1025_REG_CHIP_ID);
-                if (man_id == 0x41) { /* Analog Devices */
-                        if ((chip_id & 0xF0) == 0x20) { /* ADM1025/ADM1025A */
-                                kind = adm1025;
-                        }
-                } else
-                if (man_id == 0xA1) { /* Philips */
-                        if (client->addr != 0x2E
-                         && (chip_id & 0xF0) == 0x20) { /* NE1619 */
-                                kind = ne1619;
-                        }
-                }
-                if (kind <= 0) { /* identification failed */
-                        dev_info(&adapter->dev,
-                            "Unsupported chip (man_id=0x%02X, "
-                            "chip_id=0x%02X).\n", man_id, chip_id);
-                        return -ENODEV;
-                }
-        }
-        if (kind == adm1025) {
+        man_id = i2c_smbus_read_byte_data(client, ADM1025_REG_MAN_ID);
+        if (man_id == 0x41)
                name = "adm1025";
-        } else if (kind == ne1619) {
+        else if (man_id == 0xA1 && client->addr != 0x2E)
                name = "ne1619";
-        }
+        else
+                return -ENODEV;
        strlcpy(info->type, name, I2C_NAME_SIZE);
        return 0;
diff --git a/drivers/hwmon/adm1026.c b/drivers/hwmon/adm1026.c
index ff7de40b6e35..fb5363985e21 100644
--- a/drivers/hwmon/adm1026.c
+++ b/drivers/hwmon/adm1026.c
@@ -1672,35 +1672,26 @@ static int adm1026_detect(struct i2c_client *client, int kind,
                i2c_adapter_id(client->adapter), client->addr,
                company, verstep);
-        /* If auto-detecting, Determine the chip type. */
+        /* Determine the chip type. */
-        if (kind <= 0) {
+        dev_dbg(&adapter->dev, "Autodetecting device at %d,0x%02x...\n",
-                dev_dbg(&adapter->dev, "Autodetecting device at %d,0x%02x "
+                i2c_adapter_id(adapter), address);
-                        "...\n", i2c_adapter_id(adapter), address);
+        if (company == ADM1026_COMPANY_ANALOG_DEV
-                if (company == ADM1026_COMPANY_ANALOG_DEV
+            && verstep == ADM1026_VERSTEP_ADM1026) {
-                    && verstep == ADM1026_VERSTEP_ADM1026) {
+                /* Analog Devices ADM1026 */
-                        kind = adm1026;
+        } else if (company == ADM1026_COMPANY_ANALOG_DEV
-                } else if (company == ADM1026_COMPANY_ANALOG_DEV
+                && (verstep & 0xf0) == ADM1026_VERSTEP_GENERIC) {
-                        && (verstep & 0xf0) == ADM1026_VERSTEP_GENERIC) {
+                dev_err(&adapter->dev, "Unrecognized stepping "
-                        dev_err(&adapter->dev, "Unrecognized stepping "
+                        "0x%02x. Defaulting to ADM1026.\n", verstep);
-                                "0x%02x. Defaulting to ADM1026.\n", verstep);
+        } else if ((verstep & 0xf0) == ADM1026_VERSTEP_GENERIC) {
-                        kind = adm1026;
+                dev_err(&adapter->dev, "Found version/stepping "
-                } else if ((verstep & 0xf0) == ADM1026_VERSTEP_GENERIC) {
+                        "0x%02x. Assuming generic ADM1026.\n",
-                        dev_err(&adapter->dev, "Found version/stepping "
+                        verstep);
-                                "0x%02x. Assuming generic ADM1026.\n",
+        } else {
-                                verstep);
+                dev_dbg(&adapter->dev, "Autodetection failed\n");
-                        kind = any_chip;
+                /* Not an ADM1026... */
-                } else {
+                return -ENODEV;
-                        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 "
-                                        "found at %d,0x%02x.  Try "
-                                        "force_adm1026.\n",
-                                        i2c_adapter_id(adapter), address);
-                        }
-                        return -ENODEV;
-                }
        }
        strlcpy(info->type, "adm1026", I2C_NAME_SIZE);
        return 0;
diff --git a/drivers/hwmon/adm1029.c b/drivers/hwmon/adm1029.c
index e845b75ccee4..ef91e2a4a567 100644
--- a/drivers/hwmon/adm1029.c
+++ b/drivers/hwmon/adm1029.c
@@ -301,59 +301,36 @@ static int adm1029_detect(struct i2c_client *client, int kind,
                          struct i2c_board_info *info)
 {
        struct i2c_adapter *adapter = client->adapter;
+        u8 man_id, chip_id, temp_devices_installed, nb_fan_support;
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                return -ENODEV;
-        /* Now we do the detection and identification. A negative kind
-         * means that the driver was loaded with no force parameter
-         * (default), so we must both detect and identify the chip
-         * (actually there is only one possible kind of chip for now, adm1029).
-         * A zero kind means that the driver was loaded with the force
-         * parameter, the detection step shall be skipped. A positive kind
-         * means that the driver was loaded with the force parameter and a
-         * given kind of chip is requested, so both the detection and the
-         * identification steps are skipped. */
-        /* Default to an adm1029 if forced */
-        if (kind == 0)
-                kind = adm1029;
        /* ADM1029 doesn't have CHIP ID, check just MAN ID
         * For better detection we check also ADM1029_TEMP_DEVICES_INSTALLED,
         * ADM1029_REG_NB_FAN_SUPPORT and compare it with possible values
         * documented
         */
-        if (kind <= 0) {        /* identification */
+        man_id = i2c_smbus_read_byte_data(client, ADM1029_REG_MAN_ID);
-                u8 man_id, chip_id, temp_devices_installed, nb_fan_support;
+        chip_id = i2c_smbus_read_byte_data(client, ADM1029_REG_CHIP_ID);
+        temp_devices_installed = i2c_smbus_read_byte_data(client,
-                man_id = i2c_smbus_read_byte_data(client, ADM1029_REG_MAN_ID);
-                chip_id = i2c_smbus_read_byte_data(client, ADM1029_REG_CHIP_ID);
-                temp_devices_installed = i2c_smbus_read_byte_data(client,
                                        ADM1029_REG_TEMP_DEVICES_INSTALLED);
-                nb_fan_support = i2c_smbus_read_byte_data(client,
+        nb_fan_support = i2c_smbus_read_byte_data(client,
                                                ADM1029_REG_NB_FAN_SUPPORT);
-                /* 0x41 is Analog Devices */
+        /* 0x41 is Analog Devices */
-                if (man_id == 0x41 && (temp_devices_installed & 0xf9) == 0x01
+        if (man_id != 0x41 || (temp_devices_installed & 0xf9) != 0x01
-                    && nb_fan_support == 0x03) {
+            || nb_fan_support != 0x03)
-                        if ((chip_id & 0xF0) == 0x00) {
+                return -ENODEV;
-                                kind = adm1029;
-                        } else {
-                                /* There are no "official" CHIP ID, so actually
-                                 * we use Major/Minor revision for that */
-                                printk(KERN_INFO
-                                       "adm1029: Unknown major revision %x, "
-                                       "please let us know\n", chip_id);
-                        }
-                }
-                if (kind <= 0) {        /* identification failed */
+        if ((chip_id & 0xF0) != 0x00) {
-                        pr_debug("adm1029: Unsupported chip (man_id=0x%02X, "
+                /* There are no "official" CHIP ID, so actually
-                                 "chip_id=0x%02X)\n", man_id, chip_id);
+                 * we use Major/Minor revision for that */
-                        return -ENODEV;
+                pr_info("adm1029: Unknown major revision %x, "
-                }
+                        "please let us know\n", chip_id);
+                return -ENODEV;
        }
        strlcpy(info->type, "adm1029", I2C_NAME_SIZE);
        return 0;
diff --git a/drivers/hwmon/adm1031.c b/drivers/hwmon/adm1031.c
index 56905955352c..0e722175aae0 100644
--- a/drivers/hwmon/adm1031.c
+++ b/drivers/hwmon/adm1031.c
@@ -817,31 +817,19 @@ static int adm1031_detect(struct i2c_client *client, int kind,
                          struct i2c_board_info *info)
 {
        struct i2c_adapter *adapter = client->adapter;
-        const char *name = "";
+        const char *name;
+        int id, co;
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                return -ENODEV;
-        if (kind < 0) {
+        id = i2c_smbus_read_byte_data(client, 0x3d);
-                int id, co;
+        co = i2c_smbus_read_byte_data(client, 0x3e);
-                id = i2c_smbus_read_byte_data(client, 0x3d);
-                co = i2c_smbus_read_byte_data(client, 0x3e);
-                if (!((id == 0x31 || id == 0x30) && co == 0x41))
+        if (!((id == 0x31 || id == 0x30) && co == 0x41))
-                        return -ENODEV;
+                return -ENODEV;
-                kind = (id == 0x30) ? adm1030 : adm1031;
+        name = (id == 0x30) ? "adm1030" : "adm1031";
-        }
-        if (kind <= 0)
-                kind = adm1031;
-        /* Given the detected chip type, set the chip name and the
-         * auto fan control helper table. */
-        if (kind == adm1030) {
-                name = "adm1030";
-        } else if (kind == adm1031) {
-                name = "adm1031";
-        }
        strlcpy(info->type, name, I2C_NAME_SIZE);
        return 0;
diff --git a/drivers/hwmon/adm9240.c b/drivers/hwmon/adm9240.c
index 2444b15f2e9d..20e0481cc206 100644
--- a/drivers/hwmon/adm9240.c
+++ b/drivers/hwmon/adm9240.c
@@ -556,51 +556,34 @@ static int adm9240_detect(struct i2c_client *new_client, int kind,
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                return -ENODEV;
-        if (kind == 0) {
+        /* verify chip: reg address should match i2c address */
-                kind = adm9240;
+        if (i2c_smbus_read_byte_data(new_client, ADM9240_REG_I2C_ADDR)
-        }
+                        != address) {
+                dev_err(&adapter->dev, "detect fail: address match, 0x%02x\n",
-        if (kind < 0) {
+                        address);
+                return -ENODEV;
-                /* verify chip: reg address should match i2c address */
-                if (i2c_smbus_read_byte_data(new_client, ADM9240_REG_I2C_ADDR)
-                                != address) {
-                        dev_err(&adapter->dev, "detect fail: address match, "
-                                        "0x%02x\n", address);
-                        return -ENODEV;
-                }
-                /* check known chip manufacturer */
-                man_id = i2c_smbus_read_byte_data(new_client,
-                                ADM9240_REG_MAN_ID);
-                if (man_id == 0x23) {
-                        kind = adm9240;
-                } else if (man_id == 0xda) {
-                        kind = ds1780;
-                } else if (man_id == 0x01) {
-                        kind = lm81;
-                } else {
-                        dev_err(&adapter->dev, "detect fail: unknown manuf, "
-                                        "0x%02x\n", man_id);
-                        return -ENODEV;
-                }
-                /* successful detect, print chip info */
-                die_rev = i2c_smbus_read_byte_data(new_client,
-                                ADM9240_REG_DIE_REV);
-                dev_info(&adapter->dev, "found %s revision %u\n",
-                                man_id == 0x23 ? "ADM9240" :
-                                man_id == 0xda ? "DS1780" : "LM81", die_rev);
        }
-        /* either forced or detected chip kind */
+        /* check known chip manufacturer */
-        if (kind == adm9240) {
+        man_id = i2c_smbus_read_byte_data(new_client, ADM9240_REG_MAN_ID);
+        if (man_id == 0x23) {
                name = "adm9240";
-        } else if (kind == ds1780) {
+        } else if (man_id == 0xda) {
                name = "ds1780";
-        } else if (kind == lm81) {
+        } else if (man_id == 0x01) {
                name = "lm81";
+        } else {
+                dev_err(&adapter->dev, "detect fail: unknown manuf, 0x%02x\n",
+                        man_id);
+                return -ENODEV;
        }
+        /* successful detect, print chip info */
+        die_rev = i2c_smbus_read_byte_data(new_client, ADM9240_REG_DIE_REV);
+        dev_info(&adapter->dev, "found %s revision %u\n",
+                 man_id == 0x23 ? "ADM9240" :
+                 man_id == 0xda ? "DS1780" : "LM81", die_rev);
        strlcpy(info->type, name, I2C_NAME_SIZE);
        return 0;
diff --git a/drivers/hwmon/ads7828.c b/drivers/hwmon/ads7828.c
index 5c39b4af1b23..451977bca7d6 100644
--- a/drivers/hwmon/ads7828.c
+++ b/drivers/hwmon/ads7828.c
@@ -191,6 +191,7 @@ static int ads7828_detect(struct i2c_client *client, int kind,
                          struct i2c_board_info *info)
 {
        struct i2c_adapter *adapter = client->adapter;
+        int ch;
        /* Check we have a valid client */
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_READ_WORD_DATA))
@@ -202,20 +203,17 @@ static int ads7828_detect(struct i2c_client *client, int kind,
        - Read from the 8 channel addresses
        - Check the top 4 bits of each result are not set (12 data bits)
        */
-        if (kind < 0) {
+        for (ch = 0; ch < ADS7828_NCH; ch++) {
-                int ch;
+                u16 in_data;
-                for (ch = 0; ch < ADS7828_NCH; ch++) {
+                u8 cmd = channel_cmd_byte(ch);
-                        u16 in_data;
+                in_data = ads7828_read_value(client, cmd);
-                        u8 cmd = channel_cmd_byte(ch);
+                if (in_data & 0xF000) {
-                        in_data = ads7828_read_value(client, cmd);
+                        pr_debug("%s : Doesn't look like an ads7828 device\n",
-                        if (in_data & 0xF000) {
+                                 __func__);
-                                printk(KERN_DEBUG
+                        return -ENODEV;
-                                "%s : Doesn't look like an ads7828 device\n",
-                                __func__);
-                                return -ENODEV;
-                        }
                }
        }
        strlcpy(info->type, "ads7828", I2C_NAME_SIZE);
        return 0;
diff --git a/drivers/hwmon/adt7462.c b/drivers/hwmon/adt7462.c
index 1852f27bac51..f9c9562b6a94 100644
--- a/drivers/hwmon/adt7462.c
+++ b/drivers/hwmon/adt7462.c
@@ -1906,27 +1906,22 @@ static int adt7462_detect(struct i2c_client *client, int kind,
                          struct i2c_board_info *info)
 {
        struct i2c_adapter *adapter = client->adapter;
+        int vendor, device, revision;
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                return -ENODEV;
-        if (kind <= 0) {
+        vendor = i2c_smbus_read_byte_data(client, ADT7462_REG_VENDOR);
-                int vendor, device, revision;
+        if (vendor != ADT7462_VENDOR)
+                return -ENODEV;
-                vendor = i2c_smbus_read_byte_data(client, ADT7462_REG_VENDOR);
-                if (vendor != ADT7462_VENDOR)
-                        return -ENODEV;
-                device = i2c_smbus_read_byte_data(client, ADT7462_REG_DEVICE);
+        device = i2c_smbus_read_byte_data(client, ADT7462_REG_DEVICE);
-                if (device != ADT7462_DEVICE)
+        if (device != ADT7462_DEVICE)
-                        return -ENODEV;
+                return -ENODEV;
-                revision = i2c_smbus_read_byte_data(client,
+        revision = i2c_smbus_read_byte_data(client, ADT7462_REG_REVISION);
-                                                    ADT7462_REG_REVISION);
+        if (revision != ADT7462_REVISION)
-                if (revision != ADT7462_REVISION)
+                return -ENODEV;
-                        return -ENODEV;
-        } else
-                dev_dbg(&adapter->dev, "detection forced\n");
        strlcpy(info->type, "adt7462", I2C_NAME_SIZE);
diff --git a/drivers/hwmon/adt7470.c b/drivers/hwmon/adt7470.c
index 633e1a1e9d79..32b1750a6890 100644
--- a/drivers/hwmon/adt7470.c
+++ b/drivers/hwmon/adt7470.c
@@ -1229,27 +1229,22 @@ static int adt7470_detect(struct i2c_client *client, int kind,
                          struct i2c_board_info *info)
 {
        struct i2c_adapter *adapter = client->adapter;
+        int vendor, device, revision;
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                return -ENODEV;
-        if (kind <= 0) {
+        vendor = i2c_smbus_read_byte_data(client, ADT7470_REG_VENDOR);
-                int vendor, device, revision;
+        if (vendor != ADT7470_VENDOR)
+                return -ENODEV;
-                vendor = i2c_smbus_read_byte_data(client, ADT7470_REG_VENDOR);
-                if (vendor != ADT7470_VENDOR)
-                        return -ENODEV;
-                device = i2c_smbus_read_byte_data(client, ADT7470_REG_DEVICE);
+        device = i2c_smbus_read_byte_data(client, ADT7470_REG_DEVICE);
-                if (device != ADT7470_DEVICE)
+        if (device != ADT7470_DEVICE)
-                        return -ENODEV;
+                return -ENODEV;
-                revision = i2c_smbus_read_byte_data(client,
+        revision = i2c_smbus_read_byte_data(client, ADT7470_REG_REVISION);
-                                                    ADT7470_REG_REVISION);
+        if (revision != ADT7470_REVISION)
-                if (revision != ADT7470_REVISION)
+                return -ENODEV;
-                        return -ENODEV;
-        } else
-                dev_dbg(&adapter->dev, "detection forced\n");
        strlcpy(info->type, "adt7470", I2C_NAME_SIZE);
diff --git a/drivers/hwmon/adt7473.c b/drivers/hwmon/adt7473.c
index 0a6ce2367b42..aea244db974e 100644
--- a/drivers/hwmon/adt7473.c
+++ b/drivers/hwmon/adt7473.c
@@ -174,7 +174,6 @@ static const struct i2c_device_id adt7473_id[] = {
        { "adt7473", adt7473 },
        { }
 };
-MODULE_DEVICE_TABLE(i2c, adt7473_id);
 static struct i2c_driver adt7473_driver = {
        .class          = I2C_CLASS_HWMON,
@@ -1090,27 +1089,22 @@ static int adt7473_detect(struct i2c_client *client, int kind,
                          struct i2c_board_info *info)
 {
        struct i2c_adapter *adapter = client->adapter;
+        int vendor, device, revision;
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                return -ENODEV;
-        if (kind <= 0) {
+        vendor = i2c_smbus_read_byte_data(client, ADT7473_REG_VENDOR);
-                int vendor, device, revision;
+        if (vendor != ADT7473_VENDOR)
+                return -ENODEV;
-                vendor = i2c_smbus_read_byte_data(client, ADT7473_REG_VENDOR);
-                if (vendor != ADT7473_VENDOR)
-                        return -ENODEV;
-                device = i2c_smbus_read_byte_data(client, ADT7473_REG_DEVICE);
+        device = i2c_smbus_read_byte_data(client, ADT7473_REG_DEVICE);
-                if (device != ADT7473_DEVICE)
+        if (device != ADT7473_DEVICE)
-                        return -ENODEV;
+                return -ENODEV;
-                revision = i2c_smbus_read_byte_data(client,
+        revision = i2c_smbus_read_byte_data(client, ADT7473_REG_REVISION);
-                                                    ADT7473_REG_REVISION);
+        if (revision != ADT7473_REV_68 && revision != ADT7473_REV_69)
-                if (revision != ADT7473_REV_68 && revision != ADT7473_REV_69)
+                return -ENODEV;
-                        return -ENODEV;
-        } else
-                dev_dbg(&adapter->dev, "detection forced\n");
        strlcpy(info->type, "adt7473", I2C_NAME_SIZE);
@@ -1171,6 +1165,8 @@ static int adt7473_remove(struct i2c_client *client)
 static int __init adt7473_init(void)
 {
+        pr_notice("The adt7473 driver is deprecated, please use the adt7475 "
+                  "driver instead\n");
        return i2c_add_driver(&adt7473_driver);
 }
diff --git a/drivers/hwmon/adt7475.c b/drivers/hwmon/adt7475.c
index b5a95193c694..99abfddedbc3 100644
--- a/drivers/hwmon/adt7475.c
+++ b/drivers/hwmon/adt7475.c
@@ -3,7 +3,8 @@
 * Copyright (C) 2007-2008, Advanced Micro Devices, Inc.
 * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
 * Copyright (C) 2008 Hans de Goede <hdegoede@redhat.com>
+ * Copyright (C) 2009 Jean Delvare <khali@linux-fr.org>
+ *
 * Derived from the lm83 driver by Jean Delvare
 *
 * This program is free software; you can redistribute it and/or modify
@@ -17,6 +18,7 @@
 #include <linux/i2c.h>
 #include <linux/hwmon.h>
 #include <linux/hwmon-sysfs.h>
+#include <linux/hwmon-vid.h>
 #include <linux/err.h>
 /* Indexes for the sysfs hooks */
@@ -39,7 +41,12 @@
 /* 7475 Common Registers */
-#define REG_VOLTAGE_BASE        0x21
+#define REG_DEVREV2             0x12    /* ADT7490 only */
+#define REG_VTT                 0x1E    /* ADT7490 only */
+#define REG_EXTEND3             0x1F    /* ADT7490 only */
+#define REG_VOLTAGE_BASE        0x20
 #define REG_TEMP_BASE           0x25
 #define REG_TACH_BASE           0x28
 #define REG_PWM_BASE            0x30
@@ -47,12 +54,15 @@
 #define REG_DEVID               0x3D
 #define REG_VENDID              0x3E
+#define REG_DEVID2              0x3F
 #define REG_STATUS1             0x41
 #define REG_STATUS2             0x42
-#define REG_VOLTAGE_MIN_BASE    0x46
+#define REG_VID                 0x43    /* ADT7476 only */
-#define REG_VOLTAGE_MAX_BASE    0x47
+#define REG_VOLTAGE_MIN_BASE    0x44
+#define REG_VOLTAGE_MAX_BASE    0x45
 #define REG_TEMP_MIN_BASE       0x4E
 #define REG_TEMP_MAX_BASE       0x4F
@@ -73,16 +83,39 @@
 #define REG_TEMP_OFFSET_BASE    0x70
+#define REG_CONFIG2             0x73
 #define REG_EXTEND1             0x76
 #define REG_EXTEND2             0x77
+#define REG_CONFIG3             0x78
 #define REG_CONFIG5             0x7C
+#define REG_CONFIG4             0x7D
+#define REG_STATUS4             0x81    /* ADT7490 only */
+#define REG_VTT_MIN             0x84    /* ADT7490 only */
+#define REG_VTT_MAX             0x86    /* ADT7490 only */
+#define VID_VIDSEL              0x80    /* ADT7476 only */
+#define CONFIG2_ATTN            0x20
+#define CONFIG3_SMBALERT        0x01
+#define CONFIG3_THERM           0x02
+#define CONFIG4_PINFUNC         0x03
+#define CONFIG4_MAXDUTY         0x08
+#define CONFIG4_ATTN_IN10       0x30
+#define CONFIG4_ATTN_IN43       0xC0
 #define CONFIG5_TWOSCOMP        0x01
 #define CONFIG5_TEMPOFFSET      0x02
+#define CONFIG5_VIDGPIO         0x10    /* ADT7476 only */
 /* ADT7475 Settings */
-#define ADT7475_VOLTAGE_COUNT   2
+#define ADT7475_VOLTAGE_COUNT   5       /* Not counting Vtt */
 #define ADT7475_TEMP_COUNT      3
 #define ADT7475_TACH_COUNT      4
 #define ADT7475_PWM_COUNT       3
@@ -113,12 +146,15 @@
 #define TEMP_OFFSET_REG(idx) (REG_TEMP_OFFSET_BASE + (idx))
 #define TEMP_TRANGE_REG(idx) (REG_TEMP_TRANGE_BASE + (idx))
-static unsigned short normal_i2c[] = { 0x2e, I2C_CLIENT_END };
+static unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
-I2C_CLIENT_INSMOD_1(adt7475);
+I2C_CLIENT_INSMOD_4(adt7473, adt7475, adt7476, adt7490);
 static const struct i2c_device_id adt7475_id[] = {
+        { "adt7473", adt7473 },
        { "adt7475", adt7475 },
+        { "adt7476", adt7476 },
+        { "adt7490", adt7490 },
        { }
 };
 MODULE_DEVICE_TABLE(i2c, adt7475_id);
@@ -131,15 +167,24 @@ struct adt7475_data {
        unsigned long limits_updated;
        char valid;
+        u8 config4;
        u8 config5;
-        u16 alarms;
+        u8 has_voltage;
-        u16 voltage[3][3];
+        u8 bypass_attn;         /* Bypass voltage attenuator */
+        u8 has_pwm2:1;
+        u8 has_fan4:1;
+        u8 has_vid:1;
+        u32 alarms;
+        u16 voltage[3][6];
        u16 temp[7][3];
        u16 tach[2][4];
        u8 pwm[4][3];
        u8 range[3];
        u8 pwmctl[3];
        u8 pwmchan[3];
+        u8 vid;
+        u8 vrm;
 };
 static struct i2c_driver adt7475_driver;
@@ -196,26 +241,35 @@ static inline u16 rpm2tach(unsigned long rpm)
        return SENSORS_LIMIT((90000 * 60) / rpm, 1, 0xFFFF);
 }
-static inline int reg2vcc(u16 reg)
+/* Scaling factors for voltage inputs, taken from the ADT7490 datasheet */
-{
+static const int adt7473_in_scaling[ADT7475_VOLTAGE_COUNT + 1][2] = {
-        return (4296 * reg) / 1000;
+        { 45, 94 },     /* +2.5V */
-}
+        { 175, 525 },   /* Vccp */
+        { 68, 71 },     /* Vcc */
+        { 93, 47 },     /* +5V */
+        { 120, 20 },    /* +12V */
+        { 45, 45 },     /* Vtt */
+};
-static inline int reg2vccp(u16 reg)
+static inline int reg2volt(int channel, u16 reg, u8 bypass_attn)
 {
-        return (2929 * reg) / 1000;
+        const int *r = adt7473_in_scaling[channel];
-}
-static inline u16 vcc2reg(long vcc)
+        if (bypass_attn & (1 << channel))
-{
+                return DIV_ROUND_CLOSEST(reg * 2250, 1024);
-        vcc = SENSORS_LIMIT(vcc, 0, 4396);
+        return DIV_ROUND_CLOSEST(reg * (r[0] + r[1]) * 2250, r[1] * 1024);
-        return (vcc * 1000) / 4296;
 }
-static inline u16 vccp2reg(long vcc)
+static inline u16 volt2reg(int channel, long volt, u8 bypass_attn)
 {
-        vcc = SENSORS_LIMIT(vcc, 0, 2998);
+        const int *r = adt7473_in_scaling[channel];
-        return (vcc * 1000) / 2929;
+        long reg;
+        if (bypass_attn & (1 << channel))
+                reg = (volt * 1024) / 2250;
+        else
+                reg = (volt * r[1] * 1024) / ((r[0] + r[1]) * 2250);
+        return SENSORS_LIMIT(reg, 0, 1023) & (0xff << 2);
 }
 static u16 adt7475_read_word(struct i2c_client *client, int reg)
@@ -271,12 +325,11 @@ static ssize_t show_voltage(struct device *dev, struct device_attribute *attr,
        switch (sattr->nr) {
        case ALARM:
                return sprintf(buf, "%d\n",
-                               (data->alarms >> (sattr->index + 1)) & 1);
+                               (data->alarms >> sattr->index) & 1);
        default:
                val = data->voltage[sattr->nr][sattr->index];
                return sprintf(buf, "%d\n",
-                               sattr->index ==
+                               reg2volt(sattr->index, val, data->bypass_attn));
-                               0 ? reg2vccp(val) : reg2vcc(val));
        }
 }
@@ -296,12 +349,19 @@ static ssize_t set_voltage(struct device *dev, struct device_attribute *attr,
        mutex_lock(&data->lock);
        data->voltage[sattr->nr][sattr->index] =
-                sattr->index ? vcc2reg(val) : vccp2reg(val);
+                                volt2reg(sattr->index, val, data->bypass_attn);
-        if (sattr->nr == MIN)
+        if (sattr->index < ADT7475_VOLTAGE_COUNT) {
-                reg = VOLTAGE_MIN_REG(sattr->index);
+                if (sattr->nr == MIN)
-        else
+                        reg = VOLTAGE_MIN_REG(sattr->index);
-                reg = VOLTAGE_MAX_REG(sattr->index);
+                else
+                        reg = VOLTAGE_MAX_REG(sattr->index);
+        } else {
+                if (sattr->nr == MIN)
+                        reg = REG_VTT_MIN;
+                else
+                        reg = REG_VTT_MAX;
+        }
        i2c_smbus_write_byte_data(client, reg,
                                  data->voltage[sattr->nr][sattr->index] >> 2);
@@ -778,18 +838,103 @@ static ssize_t set_pwmfreq(struct device *dev, struct device_attribute *attr,
        return count;
 }
-static SENSOR_DEVICE_ATTR_2(in1_input, S_IRUGO, show_voltage, NULL, INPUT, 0);
+static ssize_t show_pwm_at_crit(struct device *dev,
-static SENSOR_DEVICE_ATTR_2(in1_max, S_IRUGO | S_IWUSR, show_voltage,
+                                struct device_attribute *devattr, char *buf)
+{
+        struct adt7475_data *data = adt7475_update_device(dev);
+        return sprintf(buf, "%d\n", !!(data->config4 & CONFIG4_MAXDUTY));
+}
+static ssize_t set_pwm_at_crit(struct device *dev,
+                               struct device_attribute *devattr,
+                               const char *buf, size_t count)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct adt7475_data *data = i2c_get_clientdata(client);
+        long val;
+        if (strict_strtol(buf, 10, &val))
+                return -EINVAL;
+        if (val != 0 && val != 1)
+                return -EINVAL;
+        mutex_lock(&data->lock);
+        data->config4 = i2c_smbus_read_byte_data(client, REG_CONFIG4);
+        if (val)
+                data->config4 |= CONFIG4_MAXDUTY;
+        else
+                data->config4 &= ~CONFIG4_MAXDUTY;
+        i2c_smbus_write_byte_data(client, REG_CONFIG4, data->config4);
+        mutex_unlock(&data->lock);
+        return count;
+}
+static ssize_t show_vrm(struct device *dev, struct device_attribute *devattr,
+                        char *buf)
+{
+        struct adt7475_data *data = dev_get_drvdata(dev);
+        return sprintf(buf, "%d\n", (int)data->vrm);
+}
+static ssize_t set_vrm(struct device *dev, struct device_attribute *devattr,
+                       const char *buf, size_t count)
+{
+        struct adt7475_data *data = dev_get_drvdata(dev);
+        long val;
+        if (strict_strtol(buf, 10, &val))
+                return -EINVAL;
+        if (val < 0 || val > 255)
+                return -EINVAL;
+        data->vrm = val;
+        return count;
+}
+static ssize_t show_vid(struct device *dev, struct device_attribute *devattr,
+                        char *buf)
+{
+        struct adt7475_data *data = adt7475_update_device(dev);
+        return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
+}
+static SENSOR_DEVICE_ATTR_2(in0_input, S_IRUGO, show_voltage, NULL, INPUT, 0);
+static SENSOR_DEVICE_ATTR_2(in0_max, S_IRUGO | S_IWUSR, show_voltage,
                            set_voltage, MAX, 0);
-static SENSOR_DEVICE_ATTR_2(in1_min, S_IRUGO | S_IWUSR, show_voltage,
+static SENSOR_DEVICE_ATTR_2(in0_min, S_IRUGO | S_IWUSR, show_voltage,
                            set_voltage, MIN, 0);
-static SENSOR_DEVICE_ATTR_2(in1_alarm, S_IRUGO, show_voltage, NULL, ALARM, 0);
+static SENSOR_DEVICE_ATTR_2(in0_alarm, S_IRUGO, show_voltage, NULL, ALARM, 0);
-static SENSOR_DEVICE_ATTR_2(in2_input, S_IRUGO, show_voltage, NULL, INPUT, 1);
+static SENSOR_DEVICE_ATTR_2(in1_input, S_IRUGO, show_voltage, NULL, INPUT, 1);
-static SENSOR_DEVICE_ATTR_2(in2_max, S_IRUGO | S_IWUSR, show_voltage,
+static SENSOR_DEVICE_ATTR_2(in1_max, S_IRUGO | S_IWUSR, show_voltage,
                            set_voltage, MAX, 1);
-static SENSOR_DEVICE_ATTR_2(in2_min, S_IRUGO | S_IWUSR, show_voltage,
+static SENSOR_DEVICE_ATTR_2(in1_min, S_IRUGO | S_IWUSR, show_voltage,
                            set_voltage, MIN, 1);
-static SENSOR_DEVICE_ATTR_2(in2_alarm, S_IRUGO, show_voltage, NULL, ALARM, 1);
+static SENSOR_DEVICE_ATTR_2(in1_alarm, S_IRUGO, show_voltage, NULL, ALARM, 1);
+static SENSOR_DEVICE_ATTR_2(in2_input, S_IRUGO, show_voltage, NULL, INPUT, 2);
+static SENSOR_DEVICE_ATTR_2(in2_max, S_IRUGO | S_IWUSR, show_voltage,
+                            set_voltage, MAX, 2);
+static SENSOR_DEVICE_ATTR_2(in2_min, S_IRUGO | S_IWUSR, show_voltage,
+                            set_voltage, MIN, 2);
+static SENSOR_DEVICE_ATTR_2(in2_alarm, S_IRUGO, show_voltage, NULL, ALARM, 2);
+static SENSOR_DEVICE_ATTR_2(in3_input, S_IRUGO, show_voltage, NULL, INPUT, 3);
+static SENSOR_DEVICE_ATTR_2(in3_max, S_IRUGO | S_IWUSR, show_voltage,
+                            set_voltage, MAX, 3);
+static SENSOR_DEVICE_ATTR_2(in3_min, S_IRUGO | S_IWUSR, show_voltage,
+                            set_voltage, MIN, 3);
+static SENSOR_DEVICE_ATTR_2(in3_alarm, S_IRUGO, show_voltage, NULL, ALARM, 3);
+static SENSOR_DEVICE_ATTR_2(in4_input, S_IRUGO, show_voltage, NULL, INPUT, 4);
+static SENSOR_DEVICE_ATTR_2(in4_max, S_IRUGO | S_IWUSR, show_voltage,
+                            set_voltage, MAX, 4);
+static SENSOR_DEVICE_ATTR_2(in4_min, S_IRUGO | S_IWUSR, show_voltage,
+                            set_voltage, MIN, 4);
+static SENSOR_DEVICE_ATTR_2(in4_alarm, S_IRUGO, show_voltage, NULL, ALARM, 8);
+static SENSOR_DEVICE_ATTR_2(in5_input, S_IRUGO, show_voltage, NULL, INPUT, 5);
+static SENSOR_DEVICE_ATTR_2(in5_max, S_IRUGO | S_IWUSR, show_voltage,
+                            set_voltage, MAX, 5);
+static SENSOR_DEVICE_ATTR_2(in5_min, S_IRUGO | S_IWUSR, show_voltage,
+                            set_voltage, MIN, 5);
+static SENSOR_DEVICE_ATTR_2(in5_alarm, S_IRUGO, show_voltage, NULL, ALARM, 31);
 static SENSOR_DEVICE_ATTR_2(temp1_input, S_IRUGO, show_temp, NULL, INPUT, 0);
 static SENSOR_DEVICE_ATTR_2(temp1_alarm, S_IRUGO, show_temp, NULL, ALARM, 0);
 static SENSOR_DEVICE_ATTR_2(temp1_fault, S_IRUGO, show_temp, NULL, FAULT, 0);
@@ -893,6 +1038,13 @@ static SENSOR_DEVICE_ATTR_2(pwm3_auto_point1_pwm, S_IRUGO | S_IWUSR, show_pwm,
 static SENSOR_DEVICE_ATTR_2(pwm3_auto_point2_pwm, S_IRUGO | S_IWUSR, show_pwm,
                            set_pwm, MAX, 2);
+/* Non-standard name, might need revisiting */
+static DEVICE_ATTR(pwm_use_point2_pwm_at_crit, S_IWUSR | S_IRUGO,
+                   show_pwm_at_crit, set_pwm_at_crit);
+static DEVICE_ATTR(vrm, S_IWUSR | S_IRUGO, show_vrm, set_vrm);
+static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
 static struct attribute *adt7475_attrs[] = {
        &sensor_dev_attr_in1_input.dev_attr.attr,
        &sensor_dev_attr_in1_max.dev_attr.attr,
@@ -940,60 +1092,156 @@ static struct attribute *adt7475_attrs[] = {
        &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_fan4_input.dev_attr.attr,
-        &sensor_dev_attr_fan4_min.dev_attr.attr,
-        &sensor_dev_attr_fan4_alarm.dev_attr.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_auto_channels_temp.dev_attr.attr,
        &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
        &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.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_auto_channels_temp.dev_attr.attr,
-        &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
-        &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.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_auto_channels_temp.dev_attr.attr,
        &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,
        &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr,
+        &dev_attr_pwm_use_point2_pwm_at_crit.attr,
        NULL,
 };
-struct attribute_group adt7475_attr_group = { .attrs = adt7475_attrs };
+static struct attribute *fan4_attrs[] = {
+        &sensor_dev_attr_fan4_input.dev_attr.attr,
+        &sensor_dev_attr_fan4_min.dev_attr.attr,
+        &sensor_dev_attr_fan4_alarm.dev_attr.attr,
+        NULL
+};
+static struct attribute *pwm2_attrs[] = {
+        &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_auto_channels_temp.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 *in0_attrs[] = {
+        &sensor_dev_attr_in0_input.dev_attr.attr,
+        &sensor_dev_attr_in0_max.dev_attr.attr,
+        &sensor_dev_attr_in0_min.dev_attr.attr,
+        &sensor_dev_attr_in0_alarm.dev_attr.attr,
+        NULL
+};
+static struct attribute *in3_attrs[] = {
+        &sensor_dev_attr_in3_input.dev_attr.attr,
+        &sensor_dev_attr_in3_max.dev_attr.attr,
+        &sensor_dev_attr_in3_min.dev_attr.attr,
+        &sensor_dev_attr_in3_alarm.dev_attr.attr,
+        NULL
+};
+static struct attribute *in4_attrs[] = {
+        &sensor_dev_attr_in4_input.dev_attr.attr,
+        &sensor_dev_attr_in4_max.dev_attr.attr,
+        &sensor_dev_attr_in4_min.dev_attr.attr,
+        &sensor_dev_attr_in4_alarm.dev_attr.attr,
+        NULL
+};
+static struct attribute *in5_attrs[] = {
+        &sensor_dev_attr_in5_input.dev_attr.attr,
+        &sensor_dev_attr_in5_max.dev_attr.attr,
+        &sensor_dev_attr_in5_min.dev_attr.attr,
+        &sensor_dev_attr_in5_alarm.dev_attr.attr,
+        NULL
+};
+static struct attribute *vid_attrs[] = {
+        &dev_attr_cpu0_vid.attr,
+        &dev_attr_vrm.attr,
+        NULL
+};
+static struct attribute_group adt7475_attr_group = { .attrs = adt7475_attrs };
+static struct attribute_group fan4_attr_group = { .attrs = fan4_attrs };
+static struct attribute_group pwm2_attr_group = { .attrs = pwm2_attrs };
+static struct attribute_group in0_attr_group = { .attrs = in0_attrs };
+static struct attribute_group in3_attr_group = { .attrs = in3_attrs };
+static struct attribute_group in4_attr_group = { .attrs = in4_attrs };
+static struct attribute_group in5_attr_group = { .attrs = in5_attrs };
+static struct attribute_group vid_attr_group = { .attrs = vid_attrs };
 static int adt7475_detect(struct i2c_client *client, int kind,
                          struct i2c_board_info *info)
 {
        struct i2c_adapter *adapter = client->adapter;
+        int vendid, devid, devid2;
+        const char *name;
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                return -ENODEV;
-        if (kind <= 0) {
+        vendid = adt7475_read(REG_VENDID);
-                if (adt7475_read(REG_VENDID) != 0x41 ||
+        devid2 = adt7475_read(REG_DEVID2);
-                    adt7475_read(REG_DEVID) != 0x75) {
+        if (vendid != 0x41 ||           /* Analog Devices */
-                        dev_err(&adapter->dev,
+            (devid2 & 0xf8) != 0x68)
-                                "Couldn't detect a adt7475 part at 0x%02x\n",
+                return -ENODEV;
-                                (unsigned int)client->addr);
-                        return -ENODEV;
+        devid = adt7475_read(REG_DEVID);
-                }
+        if (devid == 0x73)
+                name = "adt7473";
+        else if (devid == 0x75 && client->addr == 0x2e)
+                name = "adt7475";
+        else if (devid == 0x76)
+                name = "adt7476";
+        else if ((devid2 & 0xfc) == 0x6c)
+                name = "adt7490";
+        else {
+                dev_dbg(&adapter->dev,
+                        "Couldn't detect an ADT7473/75/76/90 part at "
+                        "0x%02x\n", (unsigned int)client->addr);
+                return -ENODEV;
        }
-        strlcpy(info->type, adt7475_id[0].name, I2C_NAME_SIZE);
+        strlcpy(info->type, name, I2C_NAME_SIZE);
        return 0;
 }
+static void adt7475_remove_files(struct i2c_client *client,
+                                 struct adt7475_data *data)
+{
+        sysfs_remove_group(&client->dev.kobj, &adt7475_attr_group);
+        if (data->has_fan4)
+                sysfs_remove_group(&client->dev.kobj, &fan4_attr_group);
+        if (data->has_pwm2)
+                sysfs_remove_group(&client->dev.kobj, &pwm2_attr_group);
+        if (data->has_voltage & (1 << 0))
+                sysfs_remove_group(&client->dev.kobj, &in0_attr_group);
+        if (data->has_voltage & (1 << 3))
+                sysfs_remove_group(&client->dev.kobj, &in3_attr_group);
+        if (data->has_voltage & (1 << 4))
+                sysfs_remove_group(&client->dev.kobj, &in4_attr_group);
+        if (data->has_voltage & (1 << 5))
+                sysfs_remove_group(&client->dev.kobj, &in5_attr_group);
+        if (data->has_vid)
+                sysfs_remove_group(&client->dev.kobj, &vid_attr_group);
+}
 static int adt7475_probe(struct i2c_client *client,
                         const struct i2c_device_id *id)
 {
+        static const char *names[] = {
+                [adt7473] = "ADT7473",
+                [adt7475] = "ADT7475",
+                [adt7476] = "ADT7476",
+                [adt7490] = "ADT7490",
+        };
        struct adt7475_data *data;
-        int i, ret = 0;
+        int i, ret = 0, revision;
+        u8 config2, config3;
        data = kzalloc(sizeof(*data), GFP_KERNEL);
        if (data == NULL)
@@ -1002,6 +1250,70 @@ static int adt7475_probe(struct i2c_client *client,
        mutex_init(&data->lock);
        i2c_set_clientdata(client, data);
+        /* Initialize device-specific values */
+        switch (id->driver_data) {
+        case adt7476:
+                data->has_voltage = 0x0e;       /* in1 to in3 */
+                revision = adt7475_read(REG_DEVID2) & 0x07;
+                break;
+        case adt7490:
+                data->has_voltage = 0x3e;       /* in1 to in5 */
+                revision = adt7475_read(REG_DEVID2) & 0x03;
+                if (revision == 0x03)
+                        revision += adt7475_read(REG_DEVREV2);
+                break;
+        default:
+                data->has_voltage = 0x06;       /* in1, in2 */
+                revision = adt7475_read(REG_DEVID2) & 0x07;
+        }
+        config3 = adt7475_read(REG_CONFIG3);
+        /* Pin PWM2 may alternatively be used for ALERT output */
+        if (!(config3 & CONFIG3_SMBALERT))
+                data->has_pwm2 = 1;
+        /* Meaning of this bit is inverted for the ADT7473-1 */
+        if (id->driver_data == adt7473 && revision >= 1)
+                data->has_pwm2 = !data->has_pwm2;
+        data->config4 = adt7475_read(REG_CONFIG4);
+        /* Pin TACH4 may alternatively be used for THERM */
+        if ((data->config4 & CONFIG4_PINFUNC) == 0x0)
+                data->has_fan4 = 1;
+        /* THERM configuration is more complex on the ADT7476 and ADT7490,
+           because 2 different pins (TACH4 and +2.5 Vin) can be used for
+           this function */
+        if (id->driver_data == adt7490) {
+                if ((data->config4 & CONFIG4_PINFUNC) == 0x1 &&
+                    !(config3 & CONFIG3_THERM))
+                        data->has_fan4 = 1;
+        }
+        if (id->driver_data == adt7476 || id->driver_data == adt7490) {
+                if (!(config3 & CONFIG3_THERM) ||
+                    (data->config4 & CONFIG4_PINFUNC) == 0x1)
+                        data->has_voltage |= (1 << 0);          /* in0 */
+        }
+        /* On the ADT7476, the +12V input pin may instead be used as VID5,
+           and VID pins may alternatively be used as GPIO */
+        if (id->driver_data == adt7476) {
+                u8 vid = adt7475_read(REG_VID);
+                if (!(vid & VID_VIDSEL))
+                        data->has_voltage |= (1 << 4);          /* in4 */
+                data->has_vid = !(adt7475_read(REG_CONFIG5) & CONFIG5_VIDGPIO);
+        }
+        /* Voltage attenuators can be bypassed, globally or individually */
+        config2 = adt7475_read(REG_CONFIG2);
+        if (config2 & CONFIG2_ATTN) {
+                data->bypass_attn = (0x3 << 3) | 0x3;
+        } else {
+                data->bypass_attn = ((data->config4 & CONFIG4_ATTN_IN10) >> 4) |
+                                    ((data->config4 & CONFIG4_ATTN_IN43) >> 3);
+        }
+        data->bypass_attn &= data->has_voltage;
        /* Call adt7475_read_pwm for all pwm's as this will reprogram any
           pwm's which are disabled to manual mode with 0% duty cycle */
        for (i = 0; i < ADT7475_PWM_COUNT; i++)
@@ -1011,16 +1323,70 @@ static int adt7475_probe(struct i2c_client *client,
        if (ret)
                goto efree;
+        /* Features that can be disabled individually */
+        if (data->has_fan4) {
+                ret = sysfs_create_group(&client->dev.kobj, &fan4_attr_group);
+                if (ret)
+                        goto eremove;
+        }
+        if (data->has_pwm2) {
+                ret = sysfs_create_group(&client->dev.kobj, &pwm2_attr_group);
+                if (ret)
+                        goto eremove;
+        }
+        if (data->has_voltage & (1 << 0)) {
+                ret = sysfs_create_group(&client->dev.kobj, &in0_attr_group);
+                if (ret)
+                        goto eremove;
+        }
+        if (data->has_voltage & (1 << 3)) {
+                ret = sysfs_create_group(&client->dev.kobj, &in3_attr_group);
+                if (ret)
+                        goto eremove;
+        }
+        if (data->has_voltage & (1 << 4)) {
+                ret = sysfs_create_group(&client->dev.kobj, &in4_attr_group);
+                if (ret)
+                        goto eremove;
+        }
+        if (data->has_voltage & (1 << 5)) {
+                ret = sysfs_create_group(&client->dev.kobj, &in5_attr_group);
+                if (ret)
+                        goto eremove;
+        }
+        if (data->has_vid) {
+                data->vrm = vid_which_vrm();
+                ret = sysfs_create_group(&client->dev.kobj, &vid_attr_group);
+                if (ret)
+                        goto eremove;
+        }
        data->hwmon_dev = hwmon_device_register(&client->dev);
        if (IS_ERR(data->hwmon_dev)) {
                ret = PTR_ERR(data->hwmon_dev);
                goto eremove;
        }
+        dev_info(&client->dev, "%s device, revision %d\n",
+                 names[id->driver_data], revision);
+        if ((data->has_voltage & 0x11) || data->has_fan4 || data->has_pwm2)
+                dev_info(&client->dev, "Optional features:%s%s%s%s%s\n",
+                         (data->has_voltage & (1 << 0)) ? " in0" : "",
+                         (data->has_voltage & (1 << 4)) ? " in4" : "",
+                         data->has_fan4 ? " fan4" : "",
+                         data->has_pwm2 ? " pwm2" : "",
+                         data->has_vid ? " vid" : "");
+        if (data->bypass_attn)
+                dev_info(&client->dev, "Bypassing attenuators on:%s%s%s%s\n",
+                         (data->bypass_attn & (1 << 0)) ? " in0" : "",
+                         (data->bypass_attn & (1 << 1)) ? " in1" : "",
+                         (data->bypass_attn & (1 << 3)) ? " in3" : "",
+                         (data->bypass_attn & (1 << 4)) ? " in4" : "");
        return 0;
 eremove:
-        sysfs_remove_group(&client->dev.kobj, &adt7475_attr_group);
+        adt7475_remove_files(client, data);
 efree:
        kfree(data);
        return ret;
@@ -1031,7 +1397,7 @@ static int adt7475_remove(struct i2c_client *client)
        struct adt7475_data *data = i2c_get_clientdata(client);
        hwmon_device_unregister(data->hwmon_dev);
-        sysfs_remove_group(&client->dev.kobj, &adt7475_attr_group);
+        adt7475_remove_files(client, data);
        kfree(data);
        return 0;
@@ -1116,7 +1482,7 @@ static struct adt7475_data *adt7475_update_device(struct device *dev)
 {
        struct i2c_client *client = to_i2c_client(dev);
        struct adt7475_data *data = i2c_get_clientdata(client);
-        u8 ext;
+        u16 ext;
        int i;
        mutex_lock(&data->lock);
@@ -1127,25 +1493,44 @@ static struct adt7475_data *adt7475_update_device(struct device *dev)
                data->alarms = adt7475_read(REG_STATUS2) << 8;
                data->alarms |= adt7475_read(REG_STATUS1);
-                ext = adt7475_read(REG_EXTEND1);
+                ext = (adt7475_read(REG_EXTEND2) << 8) |
-                for (i = 0; i < ADT7475_VOLTAGE_COUNT; i++)
+                        adt7475_read(REG_EXTEND1);
+                for (i = 0; i < ADT7475_VOLTAGE_COUNT; i++) {
+                        if (!(data->has_voltage & (1 << i)))
+                                continue;
                        data->voltage[INPUT][i] =
                                (adt7475_read(VOLTAGE_REG(i)) << 2) |
-                                ((ext >> ((i + 1) * 2)) & 3);
+                                ((ext >> (i * 2)) & 3);
+                }
-                ext = adt7475_read(REG_EXTEND2);
                for (i = 0; i < ADT7475_TEMP_COUNT; i++)
                        data->temp[INPUT][i] =
                                (adt7475_read(TEMP_REG(i)) << 2) |
-                                ((ext >> ((i + 1) * 2)) & 3);
+                                ((ext >> ((i + 5) * 2)) & 3);
-                for (i = 0; i < ADT7475_TACH_COUNT; i++)
+                if (data->has_voltage & (1 << 5)) {
+                        data->alarms |= adt7475_read(REG_STATUS4) << 24;
+                        ext = adt7475_read(REG_EXTEND3);
+                        data->voltage[INPUT][5] = adt7475_read(REG_VTT) << 2 |
+                                ((ext >> 4) & 3);
+                }
+                for (i = 0; i < ADT7475_TACH_COUNT; i++) {
+                        if (i == 3 && !data->has_fan4)
+                                continue;
                        data->tach[INPUT][i] =
                                adt7475_read_word(client, TACH_REG(i));
+                }
                /* Updated by hw when in auto mode */
-                for (i = 0; i < ADT7475_PWM_COUNT; i++)
+                for (i = 0; i < ADT7475_PWM_COUNT; i++) {
+                        if (i == 1 && !data->has_pwm2)
+                                continue;
                        data->pwm[INPUT][i] = adt7475_read(PWM_REG(i));
+                }
+                if (data->has_vid)
+                        data->vid = adt7475_read(REG_VID) & 0x3f;
                data->measure_updated = jiffies;
        }
@@ -1153,9 +1538,12 @@ static struct adt7475_data *adt7475_update_device(struct device *dev)
        /* Limits and settings, should never change update every 60 seconds */
        if (time_after(jiffies, data->limits_updated + HZ * 60) ||
            !data->valid) {
+                data->config4 = adt7475_read(REG_CONFIG4);
                data->config5 = adt7475_read(REG_CONFIG5);
                for (i = 0; i < ADT7475_VOLTAGE_COUNT; i++) {
+                        if (!(data->has_voltage & (1 << i)))
+                                continue;
                        /* Adjust values so they match the input precision */
                        data->voltage[MIN][i] =
                                adt7475_read(VOLTAGE_MIN_REG(i)) << 2;
@@ -1163,6 +1551,11 @@ static struct adt7475_data *adt7475_update_device(struct device *dev)
                                adt7475_read(VOLTAGE_MAX_REG(i)) << 2;
                }
+                if (data->has_voltage & (1 << 5)) {
+                        data->voltage[MIN][5] = adt7475_read(REG_VTT_MIN) << 2;
+                        data->voltage[MAX][5] = adt7475_read(REG_VTT_MAX) << 2;
+                }
                for (i = 0; i < ADT7475_TEMP_COUNT; i++) {
                        /* Adjust values so they match the input precision */
                        data->temp[MIN][i] =
@@ -1178,11 +1571,16 @@ static struct adt7475_data *adt7475_update_device(struct device *dev)
                }
                adt7475_read_hystersis(client);
-                for (i = 0; i < ADT7475_TACH_COUNT; i++)
+                for (i = 0; i < ADT7475_TACH_COUNT; i++) {
+                        if (i == 3 && !data->has_fan4)
+                                continue;
                        data->tach[MIN][i] =
                                adt7475_read_word(client, TACH_MIN_REG(i));
+                }
                for (i = 0; i < ADT7475_PWM_COUNT; i++) {
+                        if (i == 1 && !data->has_pwm2)
+                                continue;
                        data->pwm[MAX][i] = adt7475_read(PWM_MAX_REG(i));
                        data->pwm[MIN][i] = adt7475_read(PWM_MIN_REG(i));
                        /* Set the channel and control information */
diff --git a/drivers/hwmon/asb100.c b/drivers/hwmon/asb100.c
index 8acf82977e7b..480f80ea1fa0 100644
--- a/drivers/hwmon/asb100.c
+++ b/drivers/hwmon/asb100.c
@@ -701,6 +701,7 @@ static int asb100_detect(struct i2c_client *client, int kind,
                         struct i2c_board_info *info)
 {
        struct i2c_adapter *adapter = client->adapter;
+        int val1, val2;
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
                pr_debug("asb100.o: detect failed, "
@@ -708,50 +709,30 @@ static int asb100_detect(struct i2c_client *client, int kind,
                return -ENODEV;
        }
-        /* The chip may be stuck in some other bank than bank 0. This may
+        val1 = i2c_smbus_read_byte_data(client, ASB100_REG_BANK);
-           make reading other information impossible. Specify a force=... or
+        val2 = i2c_smbus_read_byte_data(client, ASB100_REG_CHIPMAN);
-           force_*=... parameter, and the chip will be reset to the right
-           bank. */
-        if (kind < 0) {
-                int val1 = i2c_smbus_read_byte_data(client, ASB100_REG_BANK);
-                int val2 = i2c_smbus_read_byte_data(client, ASB100_REG_CHIPMAN);
-                /* If we're in bank 0 */
-                if ((!(val1 & 0x07)) &&
-                                /* Check for ASB100 ID (low byte) */
-                                (((!(val1 & 0x80)) && (val2 != 0x94)) ||
-                                /* Check for ASB100 ID (high byte ) */
-                                ((val1 & 0x80) && (val2 != 0x06)))) {
-                        pr_debug("asb100.o: detect failed, "
-                                        "bad chip id 0x%02x!\n", val2);
-                        return -ENODEV;
-                }
-        } /* kind < 0 */
+        /* If we're in bank 0 */
+        if ((!(val1 & 0x07)) &&
+                        /* Check for ASB100 ID (low byte) */
+                        (((!(val1 & 0x80)) && (val2 != 0x94)) ||
+                        /* Check for ASB100 ID (high byte ) */
+                        ((val1 & 0x80) && (val2 != 0x06)))) {
+                pr_debug("asb100: detect failed, bad chip id 0x%02x!\n", val2);
+                return -ENODEV;
+        }
-        /* We have either had a force parameter, or we have already detected
+        /* Put it now into bank 0 and Vendor ID High Byte */
-           Winbond. Put it now into bank 0 and Vendor ID High Byte */
        i2c_smbus_write_byte_data(client, ASB100_REG_BANK,
                (i2c_smbus_read_byte_data(client, ASB100_REG_BANK) & 0x78)
                | 0x80);
        /* Determine the chip type. */
-        if (kind <= 0) {
+        val1 = i2c_smbus_read_byte_data(client, ASB100_REG_WCHIPID);
-                int val1 = i2c_smbus_read_byte_data(client, ASB100_REG_WCHIPID);
+        val2 = i2c_smbus_read_byte_data(client, ASB100_REG_CHIPMAN);
-                int val2 = i2c_smbus_read_byte_data(client, ASB100_REG_CHIPMAN);
+        if (val1 != 0x31 || val2 != 0x06)
-                if ((val1 == 0x31) && (val2 == 0x06))
+                return -ENODEV;
-                        kind = asb100;
-                else {
-                        if (kind == 0)
-                                dev_warn(&adapter->dev, "ignoring "
-                                        "'force' parameter for unknown chip "
-                                        "at adapter %d, address 0x%02x.\n",
-                                        i2c_adapter_id(adapter), client->addr);
-                        return -ENODEV;
-                }
-        }
        strlcpy(info->type, "asb100", I2C_NAME_SIZE);
diff --git a/drivers/hwmon/dme1737.c b/drivers/hwmon/dme1737.c
index 27d62574284f..4377bb0cc526 100644
--- a/drivers/hwmon/dme1737.c
+++ b/drivers/hwmon/dme1737.c
@@ -2220,33 +2220,23 @@ static int dme1737_i2c_detect(struct i2c_client *client, int kind,
                return -ENODEV;
        }
-        /* A negative kind means that the driver was loaded with no force
+        company = i2c_smbus_read_byte_data(client, DME1737_REG_COMPANY);
-         * parameter (default), so we must identify the chip. */
+        verstep = i2c_smbus_read_byte_data(client, DME1737_REG_VERSTEP);
-        if (kind < 0) {
-                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;
-                }
-        }
-        if (kind == sch5027) {
+        if (company == DME1737_COMPANY_SMSC &&
+            verstep == SCH5027_VERSTEP) {
                name = "sch5027";
-        } else {
-                kind = dme1737;
+        } else if (company == DME1737_COMPANY_SMSC &&
+                   (verstep & DME1737_VERSTEP_MASK) == DME1737_VERSTEP) {
                name = "dme1737";
+        } else {
+                return -ENODEV;
        }
        dev_info(dev, "Found a %s chip at 0x%02x (rev 0x%02x).\n",
-                 kind == sch5027 ? "SCH5027" : "DME1737", client->addr,
+                 verstep == SCH5027_VERSTEP ? "SCH5027" : "DME1737",
-                 verstep);
+                 client->addr, verstep);
        strlcpy(info->type, name, I2C_NAME_SIZE);
        return 0;
diff --git a/drivers/hwmon/ds1621.c b/drivers/hwmon/ds1621.c
index 53f88f511816..2a4c6a05b14f 100644
--- a/drivers/hwmon/ds1621.c
+++ b/drivers/hwmon/ds1621.c
@@ -237,20 +237,16 @@ static int ds1621_detect(struct i2c_client *client, int kind,
                return -ENODEV;
        /* Now, we do the remaining detection. It is lousy. */
-        if (kind < 0) {
+        /* The NVB bit should be low if no EEPROM write has been  requested
-                /* The NVB bit should be low if no EEPROM write has been 
+           during the latest 10ms, which is highly improbable in our case. */
-                   requested during the latest 10ms, which is highly 
+        conf = i2c_smbus_read_byte_data(client, DS1621_REG_CONF);
-                   improbable in our case. */
+        if (conf < 0 || conf & DS1621_REG_CONFIG_NVB)
-                conf = i2c_smbus_read_byte_data(client, DS1621_REG_CONF);
+                return -ENODEV;
-                if (conf < 0 || conf & DS1621_REG_CONFIG_NVB)
+        /* The 7 lowest bits of a temperature should always be 0. */
+        for (i = 0; i < ARRAY_SIZE(DS1621_REG_TEMP); i++) {
+                temp = i2c_smbus_read_word_data(client, DS1621_REG_TEMP[i]);
+                if (temp < 0 || (temp & 0x7f00))
                        return -ENODEV;
-                /* The 7 lowest bits of a temperature should always be 0. */
-                for (i = 0; i < ARRAY_SIZE(DS1621_REG_TEMP); i++) {
-                        temp = i2c_smbus_read_word_data(client,
-                                                        DS1621_REG_TEMP[i]);
-                        if (temp < 0 || (temp & 0x7f00))
-                                return -ENODEV;
-                }
        }
        strlcpy(info->type, "ds1621", I2C_NAME_SIZE);
diff --git a/drivers/hwmon/f71882fg.c b/drivers/hwmon/f71882fg.c
index 4146105f1a57..a95fa4256caa 100644
--- a/drivers/hwmon/f71882fg.c
+++ b/drivers/hwmon/f71882fg.c
@@ -48,6 +48,7 @@
 #define SIO_F71858_ID           0x0507  /* Chipset ID */
 #define SIO_F71862_ID           0x0601  /* Chipset ID */
 #define SIO_F71882_ID           0x0541  /* Chipset ID */
+#define SIO_F71889_ID           0x0723  /* Chipset ID */
 #define SIO_F8000_ID            0x0581  /* Chipset ID */
 #define REGION_LENGTH           8
@@ -95,12 +96,13 @@ static unsigned short force_id;
 module_param(force_id, ushort, 0);
 MODULE_PARM_DESC(force_id, "Override the detected device ID");
-enum chips { f71858fg, f71862fg, f71882fg, f8000 };
+enum chips { f71858fg, f71862fg, f71882fg, f71889fg, f8000 };
 static const char *f71882fg_names[] = {
        "f71858fg",
        "f71862fg",
        "f71882fg",
+        "f71889fg",
        "f8000",
 };
@@ -155,7 +157,7 @@ struct f71882fg_data {
        u8      pwm_auto_point_hyst[2];
        u8      pwm_auto_point_mapping[4];
        u8      pwm_auto_point_pwm[4][5];
-        u8      pwm_auto_point_temp[4][4];
+        s8      pwm_auto_point_temp[4][4];
 };
 /* Sysfs in */
@@ -258,7 +260,9 @@ static struct platform_driver f71882fg_driver = {
 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
-/* Temp and in attr for the f71858fg */
+/* Temp and in attr for the f71858fg, the f71858fg is special as it
+   has its temperature indexes start at 0 (the others start at 1) and
+   it only has 3 voltage inputs */
 static struct sensor_device_attribute_2 f71858fg_in_temp_attr[] = {
        SENSOR_ATTR_2(in0_input, S_IRUGO, show_in, NULL, 0, 0),
        SENSOR_ATTR_2(in1_input, S_IRUGO, show_in, NULL, 0, 1),
@@ -302,8 +306,8 @@ static struct sensor_device_attribute_2 f71858fg_in_temp_attr[] = {
        SENSOR_ATTR_2(temp3_fault, S_IRUGO, show_temp_fault, NULL, 0, 2),
 };
-/* Temp and in attr common to both the f71862fg and f71882fg */
+/* Temp and in attr common to the f71862fg, f71882fg and f71889fg */
-static struct sensor_device_attribute_2 f718x2fg_in_temp_attr[] = {
+static struct sensor_device_attribute_2 fxxxx_in_temp_attr[] = {
        SENSOR_ATTR_2(in0_input, S_IRUGO, show_in, NULL, 0, 0),
        SENSOR_ATTR_2(in1_input, S_IRUGO, show_in, NULL, 0, 1),
        SENSOR_ATTR_2(in2_input, S_IRUGO, show_in, NULL, 0, 2),
@@ -371,8 +375,8 @@ static struct sensor_device_attribute_2 f718x2fg_in_temp_attr[] = {
        SENSOR_ATTR_2(temp3_fault, S_IRUGO, show_temp_fault, NULL, 0, 3),
 };
-/* Temp and in attr found only on the f71882fg */
+/* For models with in1 alarm capability */
-static struct sensor_device_attribute_2 f71882fg_in_temp_attr[] = {
+static struct sensor_device_attribute_2 fxxxx_in1_alarm_attr[] = {
        SENSOR_ATTR_2(in1_max, S_IRUGO|S_IWUSR, show_in_max, store_in_max,
                0, 1),
        SENSOR_ATTR_2(in1_beep, S_IRUGO|S_IWUSR, show_in_beep, store_in_beep,
@@ -383,6 +387,7 @@ static struct sensor_device_attribute_2 f71882fg_in_temp_attr[] = {
 /* Temp and in attr for the f8000
   Note on the f8000 temp_ovt (crit) is used as max, and temp_high (max)
   is used as hysteresis value to clear alarms
+   Also like the f71858fg its temperature indexes start at 0
 */
 static struct sensor_device_attribute_2 f8000_in_temp_attr[] = {
        SENSOR_ATTR_2(in0_input, S_IRUGO, show_in, NULL, 0, 0),
@@ -413,61 +418,70 @@ static struct sensor_device_attribute_2 f8000_in_temp_attr[] = {
 };
 /* Fan / PWM attr common to all models */
-static struct sensor_device_attribute_2 fxxxx_fan_attr[] = {
+static struct sensor_device_attribute_2 fxxxx_fan_attr[4][6] = { {
        SENSOR_ATTR_2(fan1_input, S_IRUGO, show_fan, NULL, 0, 0),
        SENSOR_ATTR_2(fan1_full_speed, S_IRUGO|S_IWUSR,
                      show_fan_full_speed,
                      store_fan_full_speed, 0, 0),
        SENSOR_ATTR_2(fan1_alarm, S_IRUGO, show_fan_alarm, NULL, 0, 0),
-        SENSOR_ATTR_2(fan2_input, S_IRUGO, show_fan, NULL, 0, 1),
-        SENSOR_ATTR_2(fan2_full_speed, S_IRUGO|S_IWUSR,
-                      show_fan_full_speed,
-                      store_fan_full_speed, 0, 1),
-        SENSOR_ATTR_2(fan2_alarm, S_IRUGO, show_fan_alarm, NULL, 0, 1),
-        SENSOR_ATTR_2(fan3_input, S_IRUGO, show_fan, NULL, 0, 2),
-        SENSOR_ATTR_2(fan3_full_speed, S_IRUGO|S_IWUSR,
-                      show_fan_full_speed,
-                      store_fan_full_speed, 0, 2),
-        SENSOR_ATTR_2(fan3_alarm, S_IRUGO, show_fan_alarm, NULL, 0, 2),
        SENSOR_ATTR_2(pwm1, S_IRUGO|S_IWUSR, show_pwm, store_pwm, 0, 0),
        SENSOR_ATTR_2(pwm1_enable, S_IRUGO|S_IWUSR, show_pwm_enable,
                      store_pwm_enable, 0, 0),
        SENSOR_ATTR_2(pwm1_interpolate, S_IRUGO|S_IWUSR,
                      show_pwm_interpolate, store_pwm_interpolate, 0, 0),
-        SENSOR_ATTR_2(pwm1_auto_channels_temp, S_IRUGO|S_IWUSR,
+}, {
-                      show_pwm_auto_point_channel,
+        SENSOR_ATTR_2(fan2_input, S_IRUGO, show_fan, NULL, 0, 1),
-                      store_pwm_auto_point_channel, 0, 0),
+        SENSOR_ATTR_2(fan2_full_speed, S_IRUGO|S_IWUSR,
+                      show_fan_full_speed,
+                      store_fan_full_speed, 0, 1),
+        SENSOR_ATTR_2(fan2_alarm, S_IRUGO, show_fan_alarm, NULL, 0, 1),
        SENSOR_ATTR_2(pwm2, S_IRUGO|S_IWUSR, show_pwm, store_pwm, 0, 1),
        SENSOR_ATTR_2(pwm2_enable, S_IRUGO|S_IWUSR, show_pwm_enable,
                      store_pwm_enable, 0, 1),
        SENSOR_ATTR_2(pwm2_interpolate, S_IRUGO|S_IWUSR,
                      show_pwm_interpolate, store_pwm_interpolate, 0, 1),
-        SENSOR_ATTR_2(pwm2_auto_channels_temp, S_IRUGO|S_IWUSR,
+}, {
-                      show_pwm_auto_point_channel,
+        SENSOR_ATTR_2(fan3_input, S_IRUGO, show_fan, NULL, 0, 2),
-                      store_pwm_auto_point_channel, 0, 1),
+        SENSOR_ATTR_2(fan3_full_speed, S_IRUGO|S_IWUSR,
+                      show_fan_full_speed,
+                      store_fan_full_speed, 0, 2),
+        SENSOR_ATTR_2(fan3_alarm, S_IRUGO, show_fan_alarm, NULL, 0, 2),
        SENSOR_ATTR_2(pwm3, S_IRUGO|S_IWUSR, show_pwm, store_pwm, 0, 2),
        SENSOR_ATTR_2(pwm3_enable, S_IRUGO|S_IWUSR, show_pwm_enable,
                      store_pwm_enable, 0, 2),
        SENSOR_ATTR_2(pwm3_interpolate, S_IRUGO|S_IWUSR,
                      show_pwm_interpolate, store_pwm_interpolate, 0, 2),
-        SENSOR_ATTR_2(pwm3_auto_channels_temp, S_IRUGO|S_IWUSR,
+}, {
-                      show_pwm_auto_point_channel,
+        SENSOR_ATTR_2(fan4_input, S_IRUGO, show_fan, NULL, 0, 3),
-                      store_pwm_auto_point_channel, 0, 2),
+        SENSOR_ATTR_2(fan4_full_speed, S_IRUGO|S_IWUSR,
-};
+                      show_fan_full_speed,
+                      store_fan_full_speed, 0, 3),
+        SENSOR_ATTR_2(fan4_alarm, S_IRUGO, show_fan_alarm, NULL, 0, 3),
+        SENSOR_ATTR_2(pwm4, S_IRUGO|S_IWUSR, show_pwm, store_pwm, 0, 3),
+        SENSOR_ATTR_2(pwm4_enable, S_IRUGO|S_IWUSR, show_pwm_enable,
+                      store_pwm_enable, 0, 3),
+        SENSOR_ATTR_2(pwm4_interpolate, S_IRUGO|S_IWUSR,
+                      show_pwm_interpolate, store_pwm_interpolate, 0, 3),
+} };
-/* Fan / PWM attr for the f71862fg, less pwms and less zones per pwm than the
+/* Attr for models which can beep on Fan alarm */
-   f71882fg */
+static struct sensor_device_attribute_2 fxxxx_fan_beep_attr[] = {
-static struct sensor_device_attribute_2 f71862fg_fan_attr[] = {
        SENSOR_ATTR_2(fan1_beep, S_IRUGO|S_IWUSR, show_fan_beep,
                store_fan_beep, 0, 0),
        SENSOR_ATTR_2(fan2_beep, S_IRUGO|S_IWUSR, show_fan_beep,
                store_fan_beep, 0, 1),
        SENSOR_ATTR_2(fan3_beep, S_IRUGO|S_IWUSR, show_fan_beep,
                store_fan_beep, 0, 2),
+        SENSOR_ATTR_2(fan4_beep, S_IRUGO|S_IWUSR, show_fan_beep,
+                store_fan_beep, 0, 3),
+};
+/* PWM attr for the f71862fg, fewer pwms and fewer zones per pwm than the
+   f71858fg / f71882fg / f71889fg */
+static struct sensor_device_attribute_2 f71862fg_auto_pwm_attr[] = {
+        SENSOR_ATTR_2(pwm1_auto_channels_temp, S_IRUGO|S_IWUSR,
+                      show_pwm_auto_point_channel,
+                      store_pwm_auto_point_channel, 0, 0),
        SENSOR_ATTR_2(pwm1_auto_point1_pwm, S_IRUGO|S_IWUSR,
                      show_pwm_auto_point_pwm, store_pwm_auto_point_pwm,
                      1, 0),
@@ -487,6 +501,9 @@ static struct sensor_device_attribute_2 f71862fg_fan_attr[] = {
        SENSOR_ATTR_2(pwm1_auto_point2_temp_hyst, S_IRUGO,
                      show_pwm_auto_point_temp_hyst, NULL, 3, 0),
+        SENSOR_ATTR_2(pwm2_auto_channels_temp, S_IRUGO|S_IWUSR,
+                      show_pwm_auto_point_channel,
+                      store_pwm_auto_point_channel, 0, 1),
        SENSOR_ATTR_2(pwm2_auto_point1_pwm, S_IRUGO|S_IWUSR,
                      show_pwm_auto_point_pwm, store_pwm_auto_point_pwm,
                      1, 1),
@@ -506,6 +523,9 @@ static struct sensor_device_attribute_2 f71862fg_fan_attr[] = {
        SENSOR_ATTR_2(pwm2_auto_point2_temp_hyst, S_IRUGO,
                      show_pwm_auto_point_temp_hyst, NULL, 3, 1),
+        SENSOR_ATTR_2(pwm3_auto_channels_temp, S_IRUGO|S_IWUSR,
+                      show_pwm_auto_point_channel,
+                      store_pwm_auto_point_channel, 0, 2),
        SENSOR_ATTR_2(pwm3_auto_point1_pwm, S_IRUGO|S_IWUSR,
                      show_pwm_auto_point_pwm, store_pwm_auto_point_pwm,
                      1, 2),
@@ -526,8 +546,11 @@ static struct sensor_device_attribute_2 f71862fg_fan_attr[] = {
                      show_pwm_auto_point_temp_hyst, NULL, 3, 2),
 };
-/* Fan / PWM attr common to both the f71882fg and f71858fg */
+/* PWM attr common to the f71858fg, f71882fg and f71889fg */
-static struct sensor_device_attribute_2 f71882fg_f71858fg_fan_attr[] = {
+static struct sensor_device_attribute_2 fxxxx_auto_pwm_attr[4][14] = { {
+        SENSOR_ATTR_2(pwm1_auto_channels_temp, S_IRUGO|S_IWUSR,
+                      show_pwm_auto_point_channel,
+                      store_pwm_auto_point_channel, 0, 0),
        SENSOR_ATTR_2(pwm1_auto_point1_pwm, S_IRUGO|S_IWUSR,
                      show_pwm_auto_point_pwm, store_pwm_auto_point_pwm,
                      0, 0),
@@ -565,7 +588,10 @@ static struct sensor_device_attribute_2 f71882fg_f71858fg_fan_attr[] = {
                      show_pwm_auto_point_temp_hyst, NULL, 2, 0),
        SENSOR_ATTR_2(pwm1_auto_point4_temp_hyst, S_IRUGO,
                      show_pwm_auto_point_temp_hyst, NULL, 3, 0),
+}, {
+        SENSOR_ATTR_2(pwm2_auto_channels_temp, S_IRUGO|S_IWUSR,
+                      show_pwm_auto_point_channel,
+                      store_pwm_auto_point_channel, 0, 1),
        SENSOR_ATTR_2(pwm2_auto_point1_pwm, S_IRUGO|S_IWUSR,
                      show_pwm_auto_point_pwm, store_pwm_auto_point_pwm,
                      0, 1),
@@ -603,7 +629,10 @@ static struct sensor_device_attribute_2 f71882fg_f71858fg_fan_attr[] = {
                      show_pwm_auto_point_temp_hyst, NULL, 2, 1),
        SENSOR_ATTR_2(pwm2_auto_point4_temp_hyst, S_IRUGO,
                      show_pwm_auto_point_temp_hyst, NULL, 3, 1),
+}, {
+        SENSOR_ATTR_2(pwm3_auto_channels_temp, S_IRUGO|S_IWUSR,
+                      show_pwm_auto_point_channel,
+                      store_pwm_auto_point_channel, 0, 2),
        SENSOR_ATTR_2(pwm3_auto_point1_pwm, S_IRUGO|S_IWUSR,
                      show_pwm_auto_point_pwm, store_pwm_auto_point_pwm,
                      0, 2),
@@ -641,30 +670,7 @@ static struct sensor_device_attribute_2 f71882fg_f71858fg_fan_attr[] = {
                      show_pwm_auto_point_temp_hyst, NULL, 2, 2),
        SENSOR_ATTR_2(pwm3_auto_point4_temp_hyst, S_IRUGO,
                      show_pwm_auto_point_temp_hyst, NULL, 3, 2),
-};
+}, {
-/* Fan / PWM attr found on the f71882fg but not on the f71858fg */
-static struct sensor_device_attribute_2 f71882fg_fan_attr[] = {
-        SENSOR_ATTR_2(fan1_beep, S_IRUGO|S_IWUSR, show_fan_beep,
-                store_fan_beep, 0, 0),
-        SENSOR_ATTR_2(fan2_beep, S_IRUGO|S_IWUSR, show_fan_beep,
-                store_fan_beep, 0, 1),
-        SENSOR_ATTR_2(fan3_beep, S_IRUGO|S_IWUSR, show_fan_beep,
-                store_fan_beep, 0, 2),
-        SENSOR_ATTR_2(fan4_input, S_IRUGO, show_fan, NULL, 0, 3),
-        SENSOR_ATTR_2(fan4_full_speed, S_IRUGO|S_IWUSR,
-                      show_fan_full_speed,
-                      store_fan_full_speed, 0, 3),
-        SENSOR_ATTR_2(fan4_beep, S_IRUGO|S_IWUSR, show_fan_beep,
-                store_fan_beep, 0, 3),
-        SENSOR_ATTR_2(fan4_alarm, S_IRUGO, show_fan_alarm, NULL, 0, 3),
-        SENSOR_ATTR_2(pwm4, S_IRUGO|S_IWUSR, show_pwm, store_pwm, 0, 3),
-        SENSOR_ATTR_2(pwm4_enable, S_IRUGO|S_IWUSR, show_pwm_enable,
-                      store_pwm_enable, 0, 3),
-        SENSOR_ATTR_2(pwm4_interpolate, S_IRUGO|S_IWUSR,
-                      show_pwm_interpolate, store_pwm_interpolate, 0, 3),
        SENSOR_ATTR_2(pwm4_auto_channels_temp, S_IRUGO|S_IWUSR,
                      show_pwm_auto_point_channel,
                      store_pwm_auto_point_channel, 0, 3),
@@ -705,14 +711,20 @@ static struct sensor_device_attribute_2 f71882fg_fan_attr[] = {
                      show_pwm_auto_point_temp_hyst, NULL, 2, 3),
        SENSOR_ATTR_2(pwm4_auto_point4_temp_hyst, S_IRUGO,
                      show_pwm_auto_point_temp_hyst, NULL, 3, 3),
-};
+} };
-/* Fan / PWM attr for the f8000, zones mapped to temp instead of to pwm!
+/* Fan attr specific to the f8000 (4th fan input can only measure speed) */
-   Also the register block at offset A0 maps to TEMP1 (so our temp2, as the
-   F8000 starts counting temps at 0), B0 maps the TEMP2 and C0 maps to TEMP0 */
 static struct sensor_device_attribute_2 f8000_fan_attr[] = {
        SENSOR_ATTR_2(fan4_input, S_IRUGO, show_fan, NULL, 0, 3),
+};
+/* PWM attr for the f8000, zones mapped to temp instead of to pwm!
+   Also the register block at offset A0 maps to TEMP1 (so our temp2, as the
+   F8000 starts counting temps at 0), B0 maps the TEMP2 and C0 maps to TEMP0 */
+static struct sensor_device_attribute_2 f8000_auto_pwm_attr[] = {
+        SENSOR_ATTR_2(pwm1_auto_channels_temp, S_IRUGO|S_IWUSR,
+                      show_pwm_auto_point_channel,
+                      store_pwm_auto_point_channel, 0, 0),
        SENSOR_ATTR_2(temp1_auto_point1_pwm, S_IRUGO|S_IWUSR,
                      show_pwm_auto_point_pwm, store_pwm_auto_point_pwm,
                      0, 2),
@@ -751,6 +763,9 @@ static struct sensor_device_attribute_2 f8000_fan_attr[] = {
        SENSOR_ATTR_2(temp1_auto_point4_temp_hyst, S_IRUGO,
                      show_pwm_auto_point_temp_hyst, NULL, 3, 2),
+        SENSOR_ATTR_2(pwm2_auto_channels_temp, S_IRUGO|S_IWUSR,
+                      show_pwm_auto_point_channel,
+                      store_pwm_auto_point_channel, 0, 1),
        SENSOR_ATTR_2(temp2_auto_point1_pwm, S_IRUGO|S_IWUSR,
                      show_pwm_auto_point_pwm, store_pwm_auto_point_pwm,
                      0, 0),
@@ -789,6 +804,9 @@ static struct sensor_device_attribute_2 f8000_fan_attr[] = {
        SENSOR_ATTR_2(temp2_auto_point4_temp_hyst, S_IRUGO,
                      show_pwm_auto_point_temp_hyst, NULL, 3, 0),
+        SENSOR_ATTR_2(pwm3_auto_channels_temp, S_IRUGO|S_IWUSR,
+                      show_pwm_auto_point_channel,
+                      store_pwm_auto_point_channel, 0, 2),
        SENSOR_ATTR_2(temp3_auto_point1_pwm, S_IRUGO|S_IWUSR,
                      show_pwm_auto_point_pwm, store_pwm_auto_point_pwm,
                      0, 1),
@@ -929,7 +947,7 @@ static struct f71882fg_data *f71882fg_update_device(struct device *dev)
        /* Update once every 60 seconds */
        if ( time_after(jiffies, data->last_limits + 60 * HZ ) ||
                        !data->valid) {
-                if (data->type == f71882fg) {
+                if (data->type == f71882fg || data->type == f71889fg) {
                        data->in1_max =
                                f71882fg_read8(data, F71882FG_REG_IN1_HIGH);
                        data->in_beep =
@@ -951,7 +969,8 @@ static struct f71882fg_data *f71882fg_update_device(struct device *dev)
                                                F71882FG_REG_TEMP_HYST(1));
                }
-                if (data->type == f71862fg || data->type == f71882fg) {
+                if (data->type == f71862fg || data->type == f71882fg ||
+                    data->type == f71889fg) {
                        data->fan_beep = f71882fg_read8(data,
                                                F71882FG_REG_FAN_BEEP);
                        data->temp_beep = f71882fg_read8(data,
@@ -961,15 +980,33 @@ static struct f71882fg_data *f71882fg_update_device(struct device *dev)
                        data->temp_type[2] = (reg & 0x04) ? 2 : 4;
                        data->temp_type[3] = (reg & 0x08) ? 2 : 4;
                }
-                reg2 = f71882fg_read8(data, F71882FG_REG_PECI);
+                /* Determine temp index 1 sensor type */
-                if ((reg2 & 0x03) == 0x01)
+                if (data->type == f71889fg) {
-                        data->temp_type[1] = 6 /* PECI */;
+                        reg2 = f71882fg_read8(data, F71882FG_REG_START);
-                else if ((reg2 & 0x03) == 0x02)
+                        switch ((reg2 & 0x60) >> 5) {
-                        data->temp_type[1] = 5 /* AMDSI */;
+                        case 0x00: /* BJT / Thermistor */
-                else if (data->type == f71862fg || data->type == f71882fg)
+                                data->temp_type[1] = (reg & 0x02) ? 2 : 4;
-                        data->temp_type[1] = (reg & 0x02) ? 2 : 4;
+                                break;
-                else
+                        case 0x01: /* AMDSI */
-                        data->temp_type[1] = 2; /* Only supports BJT */
+                                data->temp_type[1] = 5;
+                                break;
+                        case 0x02: /* PECI */
+                        case 0x03: /* Ibex Peak ?? Report as PECI for now */
+                                data->temp_type[1] = 6;
+                                break;
+                        }
+                } else {
+                        reg2 = f71882fg_read8(data, F71882FG_REG_PECI);
+                        if ((reg2 & 0x03) == 0x01)
+                                data->temp_type[1] = 6; /* PECI */
+                        else if ((reg2 & 0x03) == 0x02)
+                                data->temp_type[1] = 5; /* AMDSI */
+                        else if (data->type == f71862fg ||
+                                 data->type == f71882fg)
+                                data->temp_type[1] = (reg & 0x02) ? 2 : 4;
+                        else /* f71858fg and f8000 only support BJT */
+                                data->temp_type[1] = 2;
+                }
                data->pwm_enable = f71882fg_read8(data,
                                                  F71882FG_REG_PWM_ENABLE);
@@ -1046,7 +1083,7 @@ static struct f71882fg_data *f71882fg_update_device(struct device *dev)
                if (data->type == f8000)
                        data->fan[3] = f71882fg_read16(data,
                                                F71882FG_REG_FAN(3));
-                if (data->type == f71882fg)
+                if (data->type == f71882fg || data->type == f71889fg)
                        data->in_status = f71882fg_read8(data,
                                                F71882FG_REG_IN_STATUS);
                for (nr = 0; nr < nr_ins; nr++)
@@ -1764,7 +1801,11 @@ static ssize_t store_pwm_auto_point_temp(struct device *dev,
        int pwm = to_sensor_dev_attr_2(devattr)->index;
        int point = to_sensor_dev_attr_2(devattr)->nr;
        long val = simple_strtol(buf, NULL, 10) / 1000;
-        val = SENSORS_LIMIT(val, 0, 255);
+        if (data->type == f71889fg)
+                val = SENSORS_LIMIT(val, -128, 127);
+        else
+                val = SENSORS_LIMIT(val, 0, 127);
        mutex_lock(&data->update_lock);
        f71882fg_write8(data, F71882FG_REG_POINT_TEMP(pwm, point), val);
@@ -1794,6 +1835,15 @@ static int __devinit f71882fg_create_sysfs_files(struct platform_device *pdev,
        return 0;
 }
+static void f71882fg_remove_sysfs_files(struct platform_device *pdev,
+        struct sensor_device_attribute_2 *attr, int count)
+{
+        int i;
+        for (i = 0; i < count; i++)
+                device_remove_file(&pdev->dev, &attr[i].dev_attr);
+}
 static int __devinit f71882fg_probe(struct platform_device *pdev)
 {
        struct f71882fg_data *data;
@@ -1846,16 +1896,17 @@ static int __devinit f71882fg_probe(struct platform_device *pdev)
                                        ARRAY_SIZE(f71858fg_in_temp_attr));
                        break;
                case f71882fg:
+                case f71889fg:
                        err = f71882fg_create_sysfs_files(pdev,
-                                        f71882fg_in_temp_attr,
+                                        fxxxx_in1_alarm_attr,
-                                        ARRAY_SIZE(f71882fg_in_temp_attr));
+                                        ARRAY_SIZE(fxxxx_in1_alarm_attr));
                        if (err)
                                goto exit_unregister_sysfs;
                        /* fall through! */
                case f71862fg:
                        err = f71882fg_create_sysfs_files(pdev,
-                                        f718x2fg_in_temp_attr,
+                                        fxxxx_in_temp_attr,
-                                        ARRAY_SIZE(f718x2fg_in_temp_attr));
+                                        ARRAY_SIZE(fxxxx_in_temp_attr));
                        break;
                case f8000:
                        err = f71882fg_create_sysfs_files(pdev,
@@ -1883,6 +1934,7 @@ static int __devinit f71882fg_probe(struct platform_device *pdev)
                        err = (data->pwm_enable & 0x15) != 0x15;
                        break;
                case f71882fg:
+                case f71889fg:
                        err = 0;
                        break;
                case f8000:
@@ -1897,34 +1949,55 @@ static int __devinit f71882fg_probe(struct platform_device *pdev)
                        goto exit_unregister_sysfs;
                }
-                err = f71882fg_create_sysfs_files(pdev, fxxxx_fan_attr,
+                err = f71882fg_create_sysfs_files(pdev, &fxxxx_fan_attr[0][0],
-                                        ARRAY_SIZE(fxxxx_fan_attr));
+                                ARRAY_SIZE(fxxxx_fan_attr[0]) * nr_fans);
                if (err)
                        goto exit_unregister_sysfs;
-                switch (data->type) {
+                if (data->type == f71862fg || data->type == f71882fg ||
-                case f71862fg:
+                    data->type == f71889fg) {
-                        err = f71882fg_create_sysfs_files(pdev,
-                                        f71862fg_fan_attr,
-                                        ARRAY_SIZE(f71862fg_fan_attr));
-                        break;
-                case f71882fg:
                        err = f71882fg_create_sysfs_files(pdev,
-                                        f71882fg_fan_attr,
+                                        fxxxx_fan_beep_attr, nr_fans);
-                                        ARRAY_SIZE(f71882fg_fan_attr));
                        if (err)
                                goto exit_unregister_sysfs;
-                        /* fall through! */
+                }
-                case f71858fg:
+                switch (data->type) {
+                case f71862fg:
                        err = f71882fg_create_sysfs_files(pdev,
-                                        f71882fg_f71858fg_fan_attr,
+                                        f71862fg_auto_pwm_attr,
-                                        ARRAY_SIZE(f71882fg_f71858fg_fan_attr));
+                                        ARRAY_SIZE(f71862fg_auto_pwm_attr));
                        break;
                case f8000:
                        err = f71882fg_create_sysfs_files(pdev,
                                        f8000_fan_attr,
                                        ARRAY_SIZE(f8000_fan_attr));
+                        if (err)
+                                goto exit_unregister_sysfs;
+                        err = f71882fg_create_sysfs_files(pdev,
+                                        f8000_auto_pwm_attr,
+                                        ARRAY_SIZE(f8000_auto_pwm_attr));
                        break;
+                case f71889fg:
+                        for (i = 0; i < nr_fans; i++) {
+                                data->pwm_auto_point_mapping[i] =
+                                        f71882fg_read8(data,
+                                                F71882FG_REG_POINT_MAPPING(i));
+                                if (data->pwm_auto_point_mapping[i] & 0x80)
+                                        break;
+                        }
+                        if (i != nr_fans) {
+                                dev_warn(&pdev->dev,
+                                         "Auto pwm controlled by raw digital "
+                                         "data, disabling pwm auto_point "
+                                         "sysfs attributes\n");
+                                break;
+                        }
+                        /* fall through */
+                default: /* f71858fg / f71882fg */
+                        err = f71882fg_create_sysfs_files(pdev,
+                                &fxxxx_auto_pwm_attr[0][0],
+                                ARRAY_SIZE(fxxxx_auto_pwm_attr[0]) * nr_fans);
                }
                if (err)
                        goto exit_unregister_sysfs;
@@ -1954,33 +2027,76 @@ exit_free:
 static int f71882fg_remove(struct platform_device *pdev)
 {
-        int i;
        struct f71882fg_data *data = platform_get_drvdata(pdev);
+        int nr_fans = (data->type == f71882fg) ? 4 : 3;
+        u8 start_reg = f71882fg_read8(data, F71882FG_REG_START);
        platform_set_drvdata(pdev, NULL);
        if (data->hwmon_dev)
                hwmon_device_unregister(data->hwmon_dev);
-        /* Note we are not looping over all attr arrays we have as the ones
-           below are supersets of the ones skipped. */
        device_remove_file(&pdev->dev, &dev_attr_name);
-        for (i = 0; i < ARRAY_SIZE(f718x2fg_in_temp_attr); i++)
+        if (start_reg & 0x01) {
-                device_remove_file(&pdev->dev,
+                switch (data->type) {
-                                        &f718x2fg_in_temp_attr[i].dev_attr);
+                case f71858fg:
+                        if (data->temp_config & 0x10)
-        for (i = 0; i < ARRAY_SIZE(f71882fg_in_temp_attr); i++)
+                                f71882fg_remove_sysfs_files(pdev,
-                device_remove_file(&pdev->dev,
+                                        f8000_in_temp_attr,
-                                        &f71882fg_in_temp_attr[i].dev_attr);
+                                        ARRAY_SIZE(f8000_in_temp_attr));
+                        else
+                                f71882fg_remove_sysfs_files(pdev,
+                                        f71858fg_in_temp_attr,
+                                        ARRAY_SIZE(f71858fg_in_temp_attr));
+                        break;
+                case f71882fg:
+                case f71889fg:
+                        f71882fg_remove_sysfs_files(pdev,
+                                        fxxxx_in1_alarm_attr,
+                                        ARRAY_SIZE(fxxxx_in1_alarm_attr));
+                        /* fall through! */
+                case f71862fg:
+                        f71882fg_remove_sysfs_files(pdev,
+                                        fxxxx_in_temp_attr,
+                                        ARRAY_SIZE(fxxxx_in_temp_attr));
+                        break;
+                case f8000:
+                        f71882fg_remove_sysfs_files(pdev,
+                                        f8000_in_temp_attr,
+                                        ARRAY_SIZE(f8000_in_temp_attr));
+                        break;
+                }
+        }
-        for (i = 0; i < ARRAY_SIZE(fxxxx_fan_attr); i++)
+        if (start_reg & 0x02) {
-                device_remove_file(&pdev->dev, &fxxxx_fan_attr[i].dev_attr);
+                f71882fg_remove_sysfs_files(pdev, &fxxxx_fan_attr[0][0],
+                                ARRAY_SIZE(fxxxx_fan_attr[0]) * nr_fans);
-        for (i = 0; i < ARRAY_SIZE(f71882fg_fan_attr); i++)
+                if (data->type == f71862fg || data->type == f71882fg ||
-                device_remove_file(&pdev->dev, &f71882fg_fan_attr[i].dev_attr);
+                    data->type == f71889fg)
+                        f71882fg_remove_sysfs_files(pdev,
+                                        fxxxx_fan_beep_attr, nr_fans);
-        for (i = 0; i < ARRAY_SIZE(f8000_fan_attr); i++)
+                switch (data->type) {
-                device_remove_file(&pdev->dev, &f8000_fan_attr[i].dev_attr);
+                case f71862fg:
+                        f71882fg_remove_sysfs_files(pdev,
+                                        f71862fg_auto_pwm_attr,
+                                        ARRAY_SIZE(f71862fg_auto_pwm_attr));
+                        break;
+                case f8000:
+                        f71882fg_remove_sysfs_files(pdev,
+                                        f8000_fan_attr,
+                                        ARRAY_SIZE(f8000_fan_attr));
+                        f71882fg_remove_sysfs_files(pdev,
+                                        f8000_auto_pwm_attr,
+                                        ARRAY_SIZE(f8000_auto_pwm_attr));
+                        break;
+                default: /* f71858fg / f71882fg / f71889fg */
+                        f71882fg_remove_sysfs_files(pdev,
+                                &fxxxx_auto_pwm_attr[0][0],
+                                ARRAY_SIZE(fxxxx_auto_pwm_attr[0]) * nr_fans);
+                }
+        }
        kfree(data);
@@ -2012,11 +2128,15 @@ static int __init f71882fg_find(int sioaddr, unsigned short *address,
        case SIO_F71882_ID:
                sio_data->type = f71882fg;
                break;
+        case SIO_F71889_ID:
+                sio_data->type = f71889fg;
+                break;
        case SIO_F8000_ID:
                sio_data->type = f8000;
                break;
        default:
-                printk(KERN_INFO DRVNAME ": Unsupported Fintek device\n");
+                printk(KERN_INFO DRVNAME ": Unsupported Fintek device: %04x\n",
+                       (unsigned int)devid);
                goto exit;
        }
diff --git a/drivers/hwmon/f75375s.c b/drivers/hwmon/f75375s.c
index e2107e533ede..40dfbcd3f3f2 100644
--- a/drivers/hwmon/f75375s.c
+++ b/drivers/hwmon/f75375s.c
@@ -681,30 +681,20 @@ static int f75375_detect(struct i2c_client *client, int kind,
                         struct i2c_board_info *info)
 {
        struct i2c_adapter *adapter = client->adapter;
-        u8 version = 0;
+        u16 vendid, chipid;
-        const char *name = "";
+        u8 version;
+        const char *name;
-        if (kind < 0) {
-                u16 vendid = f75375_read16(client, F75375_REG_VENDOR);
-                u16 chipid = f75375_read16(client, F75375_CHIP_ID);
-                version = f75375_read8(client, F75375_REG_VERSION);
-                if (chipid == 0x0306 && vendid == 0x1934) {
-                        kind = f75375;
-                } else if (chipid == 0x0204 && vendid == 0x1934) {
-                        kind = f75373;
-                } else {
-                        dev_err(&adapter->dev,
-                                "failed,%02X,%02X,%02X\n",
-                                chipid, version, vendid);
-                        return -ENODEV;
-                }
-        }
-        if (kind == f75375) {
+        vendid = f75375_read16(client, F75375_REG_VENDOR);
+        chipid = f75375_read16(client, F75375_CHIP_ID);
+        if (chipid == 0x0306 && vendid == 0x1934)
                name = "f75375";
-        } else if (kind == f75373) {
+        else if (chipid == 0x0204 && vendid == 0x1934)
                name = "f75373";
-        }
+        else
+                return -ENODEV;
+        version = f75375_read8(client, F75375_REG_VERSION);
        dev_info(&adapter->dev, "found %s version: %02X\n", name, version);
        strlcpy(info->type, name, I2C_NAME_SIZE);
diff --git a/drivers/hwmon/fschmd.c b/drivers/hwmon/fschmd.c
index da1b1f9488af..281829cd1533 100644
--- a/drivers/hwmon/fschmd.c
+++ b/drivers/hwmon/fschmd.c
@@ -1000,43 +1000,38 @@ static void fschmd_dmi_decode(const struct dmi_header *header, void *dummy)
        }
 }
-static int fschmd_detect(struct i2c_client *client, int kind,
+static int fschmd_detect(struct i2c_client *client, int _kind,
                         struct i2c_board_info *info)
 {
+        enum chips kind;
        struct i2c_adapter *adapter = client->adapter;
+        char id[4];
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                return -ENODEV;
        /* Detect & Identify the chip */
-        if (kind <= 0) {
+        id[0] = i2c_smbus_read_byte_data(client, FSCHMD_REG_IDENT_0);
-                char id[4];
+        id[1] = i2c_smbus_read_byte_data(client, FSCHMD_REG_IDENT_1);
+        id[2] = i2c_smbus_read_byte_data(client, FSCHMD_REG_IDENT_2);
-                id[0] = i2c_smbus_read_byte_data(client,
+        id[3] = '\0';
-                                FSCHMD_REG_IDENT_0);
-                id[1] = i2c_smbus_read_byte_data(client,
+        if (!strcmp(id, "PEG"))
-                                FSCHMD_REG_IDENT_1);
+                kind = fscpos;
-                id[2] = i2c_smbus_read_byte_data(client,
+        else if (!strcmp(id, "HER"))
-                                FSCHMD_REG_IDENT_2);
+                kind = fscher;
-                id[3] = '\0';
+        else if (!strcmp(id, "SCY"))
+                kind = fscscy;
-                if (!strcmp(id, "PEG"))
+        else if (!strcmp(id, "HRC"))
-                        kind = fscpos;
+                kind = fschrc;
-                else if (!strcmp(id, "HER"))
+        else if (!strcmp(id, "HMD"))
-                        kind = fscher;
+                kind = fschmd;
-                else if (!strcmp(id, "SCY"))
+        else if (!strcmp(id, "HDS"))
-                        kind = fscscy;
+                kind = fschds;
-                else if (!strcmp(id, "HRC"))
+        else if (!strcmp(id, "SYL"))
-                        kind = fschrc;
+                kind = fscsyl;
-                else if (!strcmp(id, "HMD"))
+        else
-                        kind = fschmd;
+                return -ENODEV;
-                else if (!strcmp(id, "HDS"))
-                        kind = fschds;
-                else if (!strcmp(id, "SYL"))
-                        kind = fscsyl;
-                else
-                        return -ENODEV;
-        }
        strlcpy(info->type, fschmd_id[kind - 1].name, I2C_NAME_SIZE);
diff --git a/drivers/hwmon/gl518sm.c b/drivers/hwmon/gl518sm.c
index 7820df45d77a..1d69458aa0b6 100644
--- a/drivers/hwmon/gl518sm.c
+++ b/drivers/hwmon/gl518sm.c
@@ -488,36 +488,21 @@ static int gl518_detect(struct i2c_client *client, int kind,
                        struct i2c_board_info *info)
 {
        struct i2c_adapter *adapter = client->adapter;
-        int i;
+        int rev;
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
                                     I2C_FUNC_SMBUS_WORD_DATA))
                return -ENODEV;
        /* Now, we do the remaining detection. */
+        if ((gl518_read_value(client, GL518_REG_CHIP_ID) != 0x80)
-        if (kind < 0) {
+         || (gl518_read_value(client, GL518_REG_CONF) & 0x80))
-                if ((gl518_read_value(client, GL518_REG_CHIP_ID) != 0x80)
+                return -ENODEV;
-                 || (gl518_read_value(client, GL518_REG_CONF) & 0x80))
-                        return -ENODEV;
-        }
        /* Determine the chip type. */
-        if (kind <= 0) {
+        rev = gl518_read_value(client, GL518_REG_REVISION);
-                i = gl518_read_value(client, GL518_REG_REVISION);
+        if (rev != 0x00 && rev != 0x80)
-                if (i == 0x00) {
+                return -ENODEV;
-                        kind = gl518sm_r00;
-                } else if (i == 0x80) {
-                        kind = gl518sm_r80;
-                } else {
-                        if (kind <= 0)
-                                dev_info(&adapter->dev,
-                                    "Ignoring 'force' parameter for unknown "
-                                    "chip at adapter %d, address 0x%02x\n",
-                                    i2c_adapter_id(adapter), client->addr);
-                        return -ENODEV;
-                }
-        }
        strlcpy(info->type, "gl518sm", I2C_NAME_SIZE);
diff --git a/drivers/hwmon/gl520sm.c b/drivers/hwmon/gl520sm.c
index 19616f2242b0..92b5720ceaff 100644
--- a/drivers/hwmon/gl520sm.c
+++ b/drivers/hwmon/gl520sm.c
@@ -691,13 +691,11 @@ static int gl520_detect(struct i2c_client *client, int kind,
                return -ENODEV;
        /* Determine the chip type. */
-        if (kind < 0) {
+        if ((gl520_read_value(client, GL520_REG_CHIP_ID) != 0x20) ||
-                if ((gl520_read_value(client, GL520_REG_CHIP_ID) != 0x20) ||
+            ((gl520_read_value(client, GL520_REG_REVISION) & 0x7f) != 0x00) ||
-                    ((gl520_read_value(client, GL520_REG_REVISION) & 0x7f) != 0x00) ||
+            ((gl520_read_value(client, GL520_REG_CONF) & 0x80) != 0x00)) {
-                    ((gl520_read_value(client, GL520_REG_CONF) & 0x80) != 0x00)) {
+                dev_dbg(&client->dev, "Unknown chip type, skipping\n");
-                        dev_dbg(&client->dev, "Unknown chip type, skipping\n");
+                return -ENODEV;
-                        return -ENODEV;
-                }
        }
        strlcpy(info->type, "gl520sm", I2C_NAME_SIZE);
diff --git a/drivers/hwmon/it87.c b/drivers/hwmon/it87.c
index a3749cb0f181..0ffe84d190bb 100644
--- a/drivers/hwmon/it87.c
+++ b/drivers/hwmon/it87.c
@@ -124,6 +124,8 @@ superio_exit(void)
 #define IT87_BASE_REG 0x60
 /* Logical device 7 registers (IT8712F and later) */
+#define IT87_SIO_GPIO3_REG      0x27
+#define IT87_SIO_GPIO5_REG      0x29
 #define IT87_SIO_PINX2_REG      0x2c    /* Pin selection */
 #define IT87_SIO_VID_REG        0xfc    /* VID value */
@@ -244,7 +246,9 @@ struct it87_sio_data {
        /* Values read from Super-I/O config space */
        u8 revision;
        u8 vid_value;
-        /* Values set based on DMI strings */
+        /* Features skipped based on config or DMI */
+        u8 skip_vid;
+        u8 skip_fan;
        u8 skip_pwm;
 };
@@ -1028,11 +1032,35 @@ static int __init it87_find(unsigned short *address,
                chip_type, *address, sio_data->revision);
        /* Read GPIO config and VID value from LDN 7 (GPIO) */
-        if (sio_data->type != it87) {
+        if (sio_data->type == it87) {
+                /* The IT8705F doesn't have VID pins at all */
+                sio_data->skip_vid = 1;
+        } else {
                int reg;
                superio_select(GPIO);
-                if (sio_data->type == it8718 || sio_data->type == it8720)
+                /* We need at least 4 VID pins */
+                reg = superio_inb(IT87_SIO_GPIO3_REG);
+                if (reg & 0x0f) {
+                        pr_info("it87: VID is disabled (pins used for GPIO)\n");
+                        sio_data->skip_vid = 1;
+                }
+                /* Check if fan3 is there or not */
+                if (reg & (1 << 6))
+                        sio_data->skip_pwm |= (1 << 2);
+                if (reg & (1 << 7))
+                        sio_data->skip_fan |= (1 << 2);
+                /* Check if fan2 is there or not */
+                reg = superio_inb(IT87_SIO_GPIO5_REG);
+                if (reg & (1 << 1))
+                        sio_data->skip_pwm |= (1 << 1);
+                if (reg & (1 << 2))
+                        sio_data->skip_fan |= (1 << 1);
+                if ((sio_data->type == it8718 || sio_data->type == it8720)
+                 && !(sio_data->skip_vid))
                        sio_data->vid_value = superio_inb(IT87_SIO_VID_REG);
                reg = superio_inb(IT87_SIO_PINX2_REG);
@@ -1236,8 +1264,7 @@ static int __devinit it87_probe(struct platform_device *pdev)
                }
        }
-        if (data->type == it8712 || data->type == it8716
+        if (!sio_data->skip_vid) {
-         || data->type == it8718 || data->type == it8720) {
                data->vrm = vid_which_vrm();
                /* VID reading from Super-I/O config space if available */
                data->vid = sio_data->vid_value;
@@ -1355,8 +1382,10 @@ static int __devinit it87_check_pwm(struct device *dev)
 /* Called when we have found a new IT87. */
 static void __devinit it87_init_device(struct platform_device *pdev)
 {
+        struct it87_sio_data *sio_data = pdev->dev.platform_data;
        struct it87_data *data = platform_get_drvdata(pdev);
        int tmp, i;
+        u8 mask;
        /* initialize to sane defaults:
         * - if the chip is in manual pwm mode, this will be overwritten with
@@ -1402,10 +1431,11 @@ static void __devinit it87_init_device(struct platform_device *pdev)
        }
        /* Check if tachometers are reset manually or by some reason */
+        mask = 0x70 & ~(sio_data->skip_fan << 4);
        data->fan_main_ctrl = it87_read_value(data, IT87_REG_FAN_MAIN_CTRL);
-        if ((data->fan_main_ctrl & 0x70) == 0) {
+        if ((data->fan_main_ctrl & mask) == 0) {
                /* Enable all fan tachometers */
-                data->fan_main_ctrl |= 0x70;
+                data->fan_main_ctrl |= mask;
                it87_write_value(data, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl);
        }
        data->has_fan = (data->fan_main_ctrl >> 4) & 0x07;
@@ -1428,6 +1458,9 @@ static void __devinit it87_init_device(struct platform_device *pdev)
                }
        }
+        /* Fan input pins may be used for alternative functions */
+        data->has_fan &= ~sio_data->skip_fan;
        /* Set current fan mode registers and the default settings for the
         * other mode registers */
        for (i = 0; i < 3; i++) {
diff --git a/drivers/hwmon/lm63.c b/drivers/hwmon/lm63.c
index 3195a265f0e9..5da66ab04f74 100644
--- a/drivers/hwmon/lm63.c
+++ b/drivers/hwmon/lm63.c
@@ -427,40 +427,34 @@ static int lm63_detect(struct i2c_client *new_client, int kind,
                       struct i2c_board_info *info)
 {
        struct i2c_adapter *adapter = new_client->adapter;
+        u8 man_id, chip_id, reg_config1, reg_config2;
+        u8 reg_alert_status, reg_alert_mask;
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                return -ENODEV;
-        if (kind < 0) { /* must identify */
+        man_id = i2c_smbus_read_byte_data(new_client, LM63_REG_MAN_ID);
-                u8 man_id, chip_id, reg_config1, reg_config2;
+        chip_id = i2c_smbus_read_byte_data(new_client, LM63_REG_CHIP_ID);
-                u8 reg_alert_status, reg_alert_mask;
+        reg_config1 = i2c_smbus_read_byte_data(new_client,
-                man_id = i2c_smbus_read_byte_data(new_client,
+                      LM63_REG_CONFIG1);
-                         LM63_REG_MAN_ID);
+        reg_config2 = i2c_smbus_read_byte_data(new_client,
-                chip_id = i2c_smbus_read_byte_data(new_client,
+                      LM63_REG_CONFIG2);
-                          LM63_REG_CHIP_ID);
+        reg_alert_status = i2c_smbus_read_byte_data(new_client,
-                reg_config1 = i2c_smbus_read_byte_data(new_client,
+                           LM63_REG_ALERT_STATUS);
-                              LM63_REG_CONFIG1);
+        reg_alert_mask = i2c_smbus_read_byte_data(new_client,
-                reg_config2 = i2c_smbus_read_byte_data(new_client,
+                         LM63_REG_ALERT_MASK);
-                              LM63_REG_CONFIG2);
-                reg_alert_status = i2c_smbus_read_byte_data(new_client,
+        if (man_id != 0x01 /* National Semiconductor */
-                                   LM63_REG_ALERT_STATUS);
+         || chip_id != 0x41 /* LM63 */
-                reg_alert_mask = i2c_smbus_read_byte_data(new_client,
+         || (reg_config1 & 0x18) != 0x00
-                                 LM63_REG_ALERT_MASK);
+         || (reg_config2 & 0xF8) != 0x00
+         || (reg_alert_status & 0x20) != 0x00
-                if (man_id == 0x01 /* National Semiconductor */
+         || (reg_alert_mask & 0xA4) != 0xA4) {
-                 && chip_id == 0x41 /* LM63 */
+                dev_dbg(&adapter->dev,
-                 && (reg_config1 & 0x18) == 0x00
+                        "Unsupported chip (man_id=0x%02X, chip_id=0x%02X)\n",
-                 && (reg_config2 & 0xF8) == 0x00
+                        man_id, chip_id);
-                 && (reg_alert_status & 0x20) == 0x00
+                return -ENODEV;
-                 && (reg_alert_mask & 0xA4) == 0xA4) {
-                        kind = lm63;
-                } else { /* failed */
-                        dev_dbg(&adapter->dev, "Unsupported chip "
-                                "(man_id=0x%02X, chip_id=0x%02X).\n",
-                                man_id, chip_id);
-                        return -ENODEV;
-                }
        }
        strlcpy(info->type, "lm63", I2C_NAME_SIZE);
diff --git a/drivers/hwmon/lm73.c b/drivers/hwmon/lm73.c
new file mode 100644
index 000000000000..0bf8b2a8e9f0
--- /dev/null
+++ b/drivers/hwmon/lm73.c
@@ -0,0 +1,205 @@
+/*
+ * LM73 Sensor driver
+ * Based on LM75
+ *
+ * Copyright (C) 2007, CenoSYS (www.cenosys.com).
+ * Copyright (C) 2009, Bollore telecom (www.bolloretelecom.eu).
+ *
+ * Guillaume Ligneul <guillaume.ligneul@gmail.com>
+ * Adrien Demarez <adrien.demarez@bolloretelecom.eu>
+ * Jeremy Laine <jeremy.laine@bolloretelecom.eu>
+ *
+ * This software program is licensed subject to the GNU General Public License
+ * (GPL).Version 2,June 1991, available at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ */
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+#include <linux/err.h>
+/* Addresses scanned */
+static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4c,
+                                        0x4d, 0x4e, I2C_CLIENT_END };
+/* Insmod parameters */
+I2C_CLIENT_INSMOD_1(lm73);
+/* LM73 registers */
+#define LM73_REG_INPUT          0x00
+#define LM73_REG_CONF           0x01
+#define LM73_REG_MAX            0x02
+#define LM73_REG_MIN            0x03
+#define LM73_REG_CTRL           0x04
+#define LM73_REG_ID             0x07
+#define LM73_ID                 0x9001 /* or 0x190 after a swab16() */
+#define DRVNAME                 "lm73"
+#define LM73_TEMP_MIN           (-40)
+#define LM73_TEMP_MAX           150
+/*-----------------------------------------------------------------------*/
+static ssize_t set_temp(struct device *dev, struct device_attribute *da,
+                        const char *buf, size_t count)
+{
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        struct i2c_client *client = to_i2c_client(dev);
+        long temp;
+        short value;
+        int status = strict_strtol(buf, 10, &temp);
+        if (status < 0)
+                return status;
+        /* Write value */
+        value = (short) SENSORS_LIMIT(temp/250, (LM73_TEMP_MIN*4),
+                (LM73_TEMP_MAX*4)) << 5;
+        i2c_smbus_write_word_data(client, attr->index, swab16(value));
+        return count;
+}
+static ssize_t show_temp(struct device *dev, struct device_attribute *da,
+                         char *buf)
+{
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
+        struct i2c_client *client = to_i2c_client(dev);
+        /* use integer division instead of equivalent right shift to
+           guarantee arithmetic shift and preserve the sign */
+        int temp = ((s16) (swab16(i2c_smbus_read_word_data(client,
+                attr->index)))*250) / 32;
+        return sprintf(buf, "%d\n", temp);
+}
+/*-----------------------------------------------------------------------*/
+/* sysfs attributes for hwmon */
+static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO,
+                        show_temp, set_temp, LM73_REG_MAX);
+static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO,
+                        show_temp, set_temp, LM73_REG_MIN);
+static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO,
+                        show_temp, NULL, LM73_REG_INPUT);
+static struct attribute *lm73_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,
+        NULL
+};
+static const struct attribute_group lm73_group = {
+        .attrs = lm73_attributes,
+};
+/*-----------------------------------------------------------------------*/
+/* device probe and removal */
+static int
+lm73_probe(struct i2c_client *client, const struct i2c_device_id *id)
+{
+        struct device *hwmon_dev;
+        int status;
+        /* Register sysfs hooks */
+        status = sysfs_create_group(&client->dev.kobj, &lm73_group);
+        if (status)
+                return status;
+        hwmon_dev = hwmon_device_register(&client->dev);
+        if (IS_ERR(hwmon_dev)) {
+                status = PTR_ERR(hwmon_dev);
+                goto exit_remove;
+        }
+        i2c_set_clientdata(client, hwmon_dev);
+        dev_info(&client->dev, "%s: sensor '%s'\n",
+                 dev_name(hwmon_dev), client->name);
+        return 0;
+exit_remove:
+        sysfs_remove_group(&client->dev.kobj, &lm73_group);
+        return status;
+}
+static int lm73_remove(struct i2c_client *client)
+{
+        struct device *hwmon_dev = i2c_get_clientdata(client);
+        hwmon_device_unregister(hwmon_dev);
+        sysfs_remove_group(&client->dev.kobj, &lm73_group);
+        i2c_set_clientdata(client, NULL);
+        return 0;
+}
+static const struct i2c_device_id lm73_ids[] = {
+        { "lm73", lm73 },
+        { /* LIST END */ }
+};
+MODULE_DEVICE_TABLE(i2c, lm73_ids);
+/* Return 0 if detection is successful, -ENODEV otherwise */
+static int lm73_detect(struct i2c_client *new_client, int kind,
+                        struct i2c_board_info *info)
+{
+        struct i2c_adapter *adapter = new_client->adapter;
+        u16 id;
+        u8 ctrl;
+        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
+                                        I2C_FUNC_SMBUS_WORD_DATA))
+                return -ENODEV;
+        /* Check device ID */
+        id = i2c_smbus_read_word_data(new_client, LM73_REG_ID);
+        ctrl = i2c_smbus_read_byte_data(new_client, LM73_REG_CTRL);
+        if ((id != LM73_ID) || (ctrl & 0x10))
+                return -ENODEV;
+        strlcpy(info->type, "lm73", I2C_NAME_SIZE);
+        return 0;
+}
+static struct i2c_driver lm73_driver = {
+        .class          = I2C_CLASS_HWMON,
+        .driver = {
+                .name   = "lm73",
+        },
+        .probe          = lm73_probe,
+        .remove         = lm73_remove,
+        .id_table       = lm73_ids,
+        .detect         = lm73_detect,
+        .address_data   = &addr_data,
+};
+/* module glue */
+static int __init sensors_lm73_init(void)
+{
+        return i2c_add_driver(&lm73_driver);
+}
+static void __exit sensors_lm73_exit(void)
+{
+        i2c_del_driver(&lm73_driver);
+}
+MODULE_AUTHOR("Guillaume Ligneul <guillaume.ligneul@gmail.com>");
+MODULE_DESCRIPTION("LM73 driver");
+MODULE_LICENSE("GPL");
+module_init(sensors_lm73_init);
+module_exit(sensors_lm73_exit);
diff --git a/drivers/hwmon/lm75.c b/drivers/hwmon/lm75.c
index 55bd87c15c9a..e392548cccb8 100644
--- a/drivers/hwmon/lm75.c
+++ b/drivers/hwmon/lm75.c
@@ -239,6 +239,7 @@ static int lm75_detect(struct i2c_client *new_client, int kind,
 {
        struct i2c_adapter *adapter = new_client->adapter;
        int i;
+        int cur, conf, hyst, os;
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
                                     I2C_FUNC_SMBUS_WORD_DATA))
@@ -251,40 +252,35 @@ static int lm75_detect(struct i2c_client *new_client, int kind,
           The cycling+unused addresses combination is not tested,
           since it would significantly slow the detection down and would
           hardly add any value. */
-        if (kind < 0) {
-                int cur, conf, hyst, os;
-                /* Unused addresses */
-                cur = i2c_smbus_read_word_data(new_client, 0);
-                conf = i2c_smbus_read_byte_data(new_client, 1);
-                hyst = i2c_smbus_read_word_data(new_client, 2);
-                if (i2c_smbus_read_word_data(new_client, 4) != hyst
-                 || 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)
-                        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)
-                        return -ENODEV;
-                /* Unused bits */
+        /* Unused addresses */
-                if (conf & 0xe0)
+        cur = i2c_smbus_read_word_data(new_client, 0);
-                        return -ENODEV;
+        conf = i2c_smbus_read_byte_data(new_client, 1);
+        hyst = i2c_smbus_read_word_data(new_client, 2);
+        if (i2c_smbus_read_word_data(new_client, 4) != hyst
+         || 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)
+                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)
+                return -ENODEV;
-                /* Addresses cycling */
+        /* Unused bits */
-                for (i = 8; i < 0xff; i += 8)
+        if (conf & 0xe0)
-                        if (i2c_smbus_read_byte_data(new_client, i + 1) != conf
+                return -ENODEV;
-                         || i2c_smbus_read_word_data(new_client, i + 2) != hyst
-                         || i2c_smbus_read_word_data(new_client, i + 3) != os)
+        /* Addresses cycling */
-                                return -ENODEV;
+        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)
+                        return -ENODEV;
        }
-        /* 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;
diff --git a/drivers/hwmon/lm77.c b/drivers/hwmon/lm77.c
index 866b401ab6e8..ac067fd19482 100644
--- a/drivers/hwmon/lm77.c
+++ b/drivers/hwmon/lm77.c
@@ -249,6 +249,7 @@ static int lm77_detect(struct i2c_client *new_client, int kind,
                       struct i2c_board_info *info)
 {
        struct i2c_adapter *adapter = new_client->adapter;
+        int i, cur, conf, hyst, crit, min, max;
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
                                     I2C_FUNC_SMBUS_WORD_DATA))
@@ -265,51 +266,48 @@ static int lm77_detect(struct i2c_client *new_client, int kind,
           4. registers cycling over 8-address boundaries
           Word-sized registers are high-byte first. */
-        if (kind < 0) {
-                int i, cur, conf, hyst, crit, min, max;
-                /* addresses cycling */
-                cur = i2c_smbus_read_word_data(new_client, 0);
-                conf = i2c_smbus_read_byte_data(new_client, 1);
-                hyst = i2c_smbus_read_word_data(new_client, 2);
-                crit = i2c_smbus_read_word_data(new_client, 3);
-                min = i2c_smbus_read_word_data(new_client, 4);
-                max = i2c_smbus_read_word_data(new_client, 5);
-                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) != crit
-                            || i2c_smbus_read_word_data(new_client, i + 4) != min
-                            || i2c_smbus_read_word_data(new_client, i + 5) != max)
-                                return -ENODEV;
-                /* sign bits */
-                if (((cur & 0x00f0) != 0xf0 && (cur & 0x00f0) != 0x0)
-                    || ((hyst & 0x00f0) != 0xf0 && (hyst & 0x00f0) != 0x0)
-                    || ((crit & 0x00f0) != 0xf0 && (crit & 0x00f0) != 0x0)
-                    || ((min & 0x00f0) != 0xf0 && (min & 0x00f0) != 0x0)
-                    || ((max & 0x00f0) != 0xf0 && (max & 0x00f0) != 0x0))
-                        return -ENODEV;
-                /* unused bits */
+        /* addresses cycling */
-                if (conf & 0xe0)
+        cur = i2c_smbus_read_word_data(new_client, 0);
+        conf = i2c_smbus_read_byte_data(new_client, 1);
+        hyst = i2c_smbus_read_word_data(new_client, 2);
+        crit = i2c_smbus_read_word_data(new_client, 3);
+        min = i2c_smbus_read_word_data(new_client, 4);
+        max = i2c_smbus_read_word_data(new_client, 5);
+        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) != crit
+                 || i2c_smbus_read_word_data(new_client, i + 4) != min
+                 || i2c_smbus_read_word_data(new_client, i + 5) != max)
                        return -ENODEV;
+        }
-                /* 0x06 and 0x07 return the last read value */
+        /* sign bits */
-                cur = i2c_smbus_read_word_data(new_client, 0);
+        if (((cur & 0x00f0) != 0xf0 && (cur & 0x00f0) != 0x0)
-                if (i2c_smbus_read_word_data(new_client, 6) != cur
+         || ((hyst & 0x00f0) != 0xf0 && (hyst & 0x00f0) != 0x0)
-                    || i2c_smbus_read_word_data(new_client, 7) != cur)
+         || ((crit & 0x00f0) != 0xf0 && (crit & 0x00f0) != 0x0)
-                        return -ENODEV;
+         || ((min & 0x00f0) != 0xf0 && (min & 0x00f0) != 0x0)
-                hyst = i2c_smbus_read_word_data(new_client, 2);
+         || ((max & 0x00f0) != 0xf0 && (max & 0x00f0) != 0x0))
-                if (i2c_smbus_read_word_data(new_client, 6) != hyst
+                return -ENODEV;
-                    || i2c_smbus_read_word_data(new_client, 7) != hyst)
-                        return -ENODEV;
-                min = i2c_smbus_read_word_data(new_client, 4);
-                if (i2c_smbus_read_word_data(new_client, 6) != min
-                    || i2c_smbus_read_word_data(new_client, 7) != min)
-                        return -ENODEV;
-        }
+        /* unused bits */
+        if (conf & 0xe0)
+                return -ENODEV;
+        /* 0x06 and 0x07 return the last read value */
+        cur = i2c_smbus_read_word_data(new_client, 0);
+        if (i2c_smbus_read_word_data(new_client, 6) != cur
+         || i2c_smbus_read_word_data(new_client, 7) != cur)
+                return -ENODEV;
+        hyst = i2c_smbus_read_word_data(new_client, 2);
+        if (i2c_smbus_read_word_data(new_client, 6) != hyst
+         || i2c_smbus_read_word_data(new_client, 7) != hyst)
+                return -ENODEV;
+        min = i2c_smbus_read_word_data(new_client, 4);
+        if (i2c_smbus_read_word_data(new_client, 6) != min
+         || i2c_smbus_read_word_data(new_client, 7) != min)
+                return -ENODEV;
        strlcpy(info->type, "lm77", I2C_NAME_SIZE);
diff --git a/drivers/hwmon/lm78.c b/drivers/hwmon/lm78.c
index f7e70163e016..5978291cebb3 100644
--- a/drivers/hwmon/lm78.c
+++ b/drivers/hwmon/lm78.c
@@ -576,52 +576,34 @@ static int lm78_i2c_detect(struct i2c_client *client, int kind,
        if (isa)
                mutex_lock(&isa->update_lock);
-        if (kind < 0) {
+        if ((i2c_smbus_read_byte_data(client, LM78_REG_CONFIG) & 0x80)
-                if ((i2c_smbus_read_byte_data(client, LM78_REG_CONFIG) & 0x80)
+         || i2c_smbus_read_byte_data(client, LM78_REG_I2C_ADDR) != address)
-                 || i2c_smbus_read_byte_data(client, LM78_REG_I2C_ADDR)
+                goto err_nodev;
-                    != address)
-                        goto err_nodev;
+        /* Explicitly prevent the misdetection of Winbond chips */
+        i = i2c_smbus_read_byte_data(client, 0x4f);
-                /* Explicitly prevent the misdetection of Winbond chips */
+        if (i == 0xa3 || i == 0x5c)
-                i = i2c_smbus_read_byte_data(client, 0x4f);
+                goto err_nodev;
-                if (i == 0xa3 || i == 0x5c)
-                        goto err_nodev;
-        }
        /* Determine the chip type. */
-        if (kind <= 0) {
+        i = i2c_smbus_read_byte_data(client, LM78_REG_CHIPID);
-                i = i2c_smbus_read_byte_data(client, LM78_REG_CHIPID);
+        if (i == 0x00 || i == 0x20      /* LM78 */
-                if (i == 0x00 || i == 0x20      /* LM78 */
+         || i == 0x40)                  /* LM78-J */
-                 || i == 0x40)                  /* LM78-J */
+                client_name = "lm78";
-                        kind = lm78;
+        else if ((i & 0xfe) == 0xc0)
-                else if ((i & 0xfe) == 0xc0)
+                client_name = "lm79";
-                        kind = lm79;
+        else
-                else {
+                goto err_nodev;
-                        if (kind == 0)
-                                dev_warn(&adapter->dev, "Ignoring 'force' "
-                                        "parameter for unknown chip at "
-                                        "adapter %d, address 0x%02x\n",
-                                        i2c_adapter_id(adapter), address);
-                        goto err_nodev;
-                }
-                if (lm78_alias_detect(client, i)) {
+        if (lm78_alias_detect(client, i)) {
-                        dev_dbg(&adapter->dev, "Device at 0x%02x appears to "
+                dev_dbg(&adapter->dev, "Device at 0x%02x appears to "
-                                "be the same as ISA device\n", address);
+                        "be the same as ISA device\n", address);
-                        goto err_nodev;
+                goto err_nodev;
-                }
        }
        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;
diff --git a/drivers/hwmon/lm83.c b/drivers/hwmon/lm83.c
index e59e2d1f080c..08b03e6ed0b7 100644
--- a/drivers/hwmon/lm83.c
+++ b/drivers/hwmon/lm83.c
@@ -1,7 +1,7 @@
 /*
 * lm83.c - Part of lm_sensors, Linux kernel modules for hardware
 *          monitoring
- * Copyright (C) 2003-2008  Jean Delvare <khali@linux-fr.org>
+ * Copyright (C) 2003-2009  Jean Delvare <khali@linux-fr.org>
 *
 * Heavily inspired from the lm78, lm75 and adm1021 drivers. The LM83 is
 * a sensor chip made by National Semiconductor. It reports up to four
@@ -295,69 +295,40 @@ static int lm83_detect(struct i2c_client *new_client, int kind,
                       struct i2c_board_info *info)
 {
        struct i2c_adapter *adapter = new_client->adapter;
-        const char *name = "";
+        const char *name;
+        u8 man_id, chip_id;
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                return -ENODEV;
-        /* Now we do the detection and identification. A negative kind
+        /* Detection */
-         * means that the driver was loaded with no force parameter
+        if ((i2c_smbus_read_byte_data(new_client, LM83_REG_R_STATUS1) & 0xA8) ||
-         * (default), so we must both detect and identify the chip
+            (i2c_smbus_read_byte_data(new_client, LM83_REG_R_STATUS2) & 0x48) ||
-         * (actually there is only one possible kind of chip for now, LM83).
+            (i2c_smbus_read_byte_data(new_client, LM83_REG_R_CONFIG) & 0x41)) {
-         * A zero kind means that the driver was loaded with the force
+                dev_dbg(&adapter->dev, "LM83 detection failed at 0x%02x\n",
-         * parameter, the detection step shall be skipped. A positive kind
+                        new_client->addr);
-         * means that the driver was loaded with the force parameter and a
+                return -ENODEV;
-         * given kind of chip is requested, so both the detection and the
-         * identification steps are skipped. */
-        /* Default to an LM83 if forced */
-        if (kind == 0)
-                kind = lm83;
-        if (kind < 0) { /* detection */
-                if (((i2c_smbus_read_byte_data(new_client, LM83_REG_R_STATUS1)
-                    & 0xA8) != 0x00) ||
-                    ((i2c_smbus_read_byte_data(new_client, LM83_REG_R_STATUS2)
-                    & 0x48) != 0x00) ||
-                    ((i2c_smbus_read_byte_data(new_client, LM83_REG_R_CONFIG)
-                    & 0x41) != 0x00)) {
-                        dev_dbg(&adapter->dev,
-                                "LM83 detection failed at 0x%02x.\n",
-                                new_client->addr);
-                        return -ENODEV;
-                }
        }
-        if (kind <= 0) { /* identification */
+        /* Identification */
-                u8 man_id, chip_id;
+        man_id = i2c_smbus_read_byte_data(new_client, LM83_REG_R_MAN_ID);
+        if (man_id != 0x01)     /* National Semiconductor */
-                man_id = i2c_smbus_read_byte_data(new_client,
+                return -ENODEV;
-                    LM83_REG_R_MAN_ID);
-                chip_id = i2c_smbus_read_byte_data(new_client,
-                    LM83_REG_R_CHIP_ID);
-                if (man_id == 0x01) { /* National Semiconductor */
-                        if (chip_id == 0x03) {
-                                kind = lm83;
-                        } else
-                        if (chip_id == 0x01) {
-                                kind = lm82;
-                        }
-                }
-                if (kind <= 0) { /* identification failed */
-                        dev_info(&adapter->dev,
-                            "Unsupported chip (man_id=0x%02X, "
-                            "chip_id=0x%02X).\n", man_id, chip_id);
-                        return -ENODEV;
-                }
-        }
-        if (kind == lm83) {
+        chip_id = i2c_smbus_read_byte_data(new_client, LM83_REG_R_CHIP_ID);
+        switch (chip_id) {
+        case 0x03:
                name = "lm83";
-        } else
+                break;
-        if (kind == lm82) {
+        case 0x01:
                name = "lm82";
+                break;
+        default:
+                /* identification failed */
+                dev_info(&adapter->dev,
+                         "Unsupported chip (man_id=0x%02X, chip_id=0x%02X)\n",
+                         man_id, chip_id);
+                return -ENODEV;
        }
        strlcpy(info->type, name, I2C_NAME_SIZE);
diff --git a/drivers/hwmon/lm85.c b/drivers/hwmon/lm85.c
index 6c53d987de10..d56da2e74708 100644
--- a/drivers/hwmon/lm85.c
+++ b/drivers/hwmon/lm85.c
@@ -5,7 +5,7 @@
    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>
+    Copyright (C) 2007--2009  Jean Delvare <khali@linux-fr.org>
    Chip details at           <http://www.national.com/ds/LM/LM85.pdf>
@@ -1162,107 +1162,80 @@ static int lm85_detect(struct i2c_client *client, int kind,
        struct i2c_adapter *adapter = client->adapter;
        int address = client->addr;
        const char *type_name;
+        int company, verstep;
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
                /* We need to be able to do byte I/O */
                return -ENODEV;
        }
-        /* If auto-detecting, determine the chip type */
+        /* Determine the chip type */
-        if (kind < 0) {
+        company = lm85_read_value(client, LM85_REG_COMPANY);
-                int company = lm85_read_value(client, LM85_REG_COMPANY);
+        verstep = lm85_read_value(client, LM85_REG_VERSTEP);
-                int verstep = lm85_read_value(client, LM85_REG_VERSTEP);
+        dev_dbg(&adapter->dev, "Detecting device at 0x%02x with "
-                dev_dbg(&adapter->dev, "Detecting device at 0x%02x with "
+                "COMPANY: 0x%02x and VERSTEP: 0x%02x\n",
-                        "COMPANY: 0x%02x and VERSTEP: 0x%02x\n",
+                address, company, verstep);
-                        address, company, verstep);
+        /* All supported chips have the version in common */
-                /* All supported chips have the version in common */
+        if ((verstep & LM85_VERSTEP_VMASK) != LM85_VERSTEP_GENERIC &&
-                if ((verstep & LM85_VERSTEP_VMASK) != LM85_VERSTEP_GENERIC &&
+            (verstep & LM85_VERSTEP_VMASK) != LM85_VERSTEP_GENERIC2) {
-                    (verstep & LM85_VERSTEP_VMASK) != LM85_VERSTEP_GENERIC2) {
+                dev_dbg(&adapter->dev,
-                        dev_dbg(&adapter->dev, "Autodetection failed: "
+                        "Autodetection failed: unsupported version\n");
-                                "unsupported version\n");
+                return -ENODEV;
-                        return -ENODEV;
+        }
-                }
+        type_name = "lm85";
-                kind = any_chip;
+        /* Now, refine the detection */
-                /* Now, refine the detection */
+        if (company == LM85_COMPANY_NATIONAL) {
-                if (company == LM85_COMPANY_NATIONAL) {
+                switch (verstep) {
-                        switch (verstep) {
+                case LM85_VERSTEP_LM85C:
-                        case LM85_VERSTEP_LM85C:
+                        type_name = "lm85c";
-                                kind = lm85c;
+                        break;
-                                break;
+                case LM85_VERSTEP_LM85B:
-                        case LM85_VERSTEP_LM85B:
+                        type_name = "lm85b";
-                                kind = lm85b;
+                        break;
-                                break;
+                case LM85_VERSTEP_LM96000_1:
-                        case LM85_VERSTEP_LM96000_1:
+                case LM85_VERSTEP_LM96000_2:
-                        case LM85_VERSTEP_LM96000_2:
+                        /* Check for Winbond WPCD377I */
-                                /* Check for Winbond WPCD377I */
+                        if (lm85_is_fake(client)) {
-                                if (lm85_is_fake(client)) {
+                                dev_dbg(&adapter->dev,
-                                        dev_dbg(&adapter->dev,
+                                        "Found Winbond WPCD377I, ignoring\n");
-                                                "Found Winbond WPCD377I, "
+                                return -ENODEV;
-                                                "ignoring\n");
-                                        return -ENODEV;
-                                }
-                                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;
-                        case LM85_VERSTEP_ADT7468_1:
-                        case LM85_VERSTEP_ADT7468_2:
-                                kind = adt7468;
-                                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;
                        }
-                } else {
+                        break;
-                        dev_dbg(&adapter->dev, "Autodetection failed: "
+                }
-                                "unknown vendor\n");
+        } else if (company == LM85_COMPANY_ANALOG_DEV) {
-                        return -ENODEV;
+                switch (verstep) {
+                case LM85_VERSTEP_ADM1027:
+                        type_name = "adm1027";
+                        break;
+                case LM85_VERSTEP_ADT7463:
+                case LM85_VERSTEP_ADT7463C:
+                        type_name = "adt7463";
+                        break;
+                case LM85_VERSTEP_ADT7468_1:
+                case LM85_VERSTEP_ADT7468_2:
+                        type_name = "adt7468";
+                        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 */
+                        type_name = "emc6d100";
+                        break;
+                case LM85_VERSTEP_EMC6D102:
+                        type_name = "emc6d102";
+                        break;
+                }
+        } else {
+                dev_dbg(&adapter->dev,
+                        "Autodetection failed: unknown vendor\n");
+                return -ENODEV;
        }
-        switch (kind) {
-        case lm85b:
-                type_name = "lm85b";
-                break;
-        case lm85c:
-                type_name = "lm85c";
-                break;
-        case adm1027:
-                type_name = "adm1027";
-                break;
-        case adt7463:
-                type_name = "adt7463";
-                break;
-        case adt7468:
-                type_name = "adt7468";
-                break;
-        case emc6d100:
-                type_name = "emc6d100";
-                break;
-        case emc6d102:
-                type_name = "emc6d102";
-                break;
-        default:
-                type_name = "lm85";
-        }
        strlcpy(info->type, type_name, I2C_NAME_SIZE);
        return 0;
diff --git a/drivers/hwmon/lm87.c b/drivers/hwmon/lm87.c
index 2e4a3cea95f7..4929b1815eee 100644
--- a/drivers/hwmon/lm87.c
+++ b/drivers/hwmon/lm87.c
@@ -666,37 +666,32 @@ static int lm87_detect(struct i2c_client *new_client, int kind,
                       struct i2c_board_info *info)
 {
        struct i2c_adapter *adapter = new_client->adapter;
-        static const char *names[] = { "lm87", "adm1024" };
+        const char *name;
+        u8 cid, rev;
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                return -ENODEV;
-        /* Default to an LM87 if forced */
+        if (lm87_read_value(new_client, LM87_REG_CONFIG) & 0x80)
-        if (kind == 0)
+                return -ENODEV;
-                kind = lm87;
        /* Now, we do the remaining detection. */
-        if (kind < 0) {
+        cid = lm87_read_value(new_client, LM87_REG_COMPANY_ID);
-                u8 cid = lm87_read_value(new_client, LM87_REG_COMPANY_ID);
+        rev = lm87_read_value(new_client, LM87_REG_REVISION);
-                u8 rev = lm87_read_value(new_client, LM87_REG_REVISION);
+        if (cid == 0x02                 /* National Semiconductor */
-                if (cid == 0x02                 /* National Semiconductor */
+         && (rev >= 0x01 && rev <= 0x08))
-                 && (rev >= 0x01 && rev <= 0x08))
+                name = "lm87";
-                        kind = lm87;
+        else if (cid == 0x41            /* Analog Devices */
-                else if (cid == 0x41            /* Analog Devices */
+              && (rev & 0xf0) == 0x10)
-                      && (rev & 0xf0) == 0x10)
+                name = "adm1024";
-                        kind = adm1024;
+        else {
+                dev_dbg(&adapter->dev, "LM87 detection failed at 0x%02x\n",
-                if (kind < 0
+                        new_client->addr);
-                 || (lm87_read_value(new_client, LM87_REG_CONFIG) & 0x80)) {
+                return -ENODEV;
-                        dev_dbg(&adapter->dev,
-                                "LM87 detection failed at 0x%02x.\n",
-                                new_client->addr);
-                        return -ENODEV;
-                }
        }
-        strlcpy(info->type, names[kind - 1], I2C_NAME_SIZE);
+        strlcpy(info->type, name, I2C_NAME_SIZE);
        return 0;
 }
diff --git a/drivers/hwmon/lm90.c b/drivers/hwmon/lm90.c
index 1aff7575799d..b7c905f50ed4 100644
--- a/drivers/hwmon/lm90.c
+++ b/drivers/hwmon/lm90.c
@@ -1,7 +1,7 @@
 /*
 * lm90.c - Part of lm_sensors, Linux kernel modules for hardware
 *          monitoring
- * Copyright (C) 2003-2008  Jean Delvare <khali@linux-fr.org>
+ * Copyright (C) 2003-2009  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
@@ -661,154 +661,118 @@ static int lm90_detect(struct i2c_client *new_client, int kind,
 {
        struct i2c_adapter *adapter = new_client->adapter;
        int address = new_client->addr;
-        const char *name = "";
+        const char *name = NULL;
+        int man_id, chip_id, reg_config1, reg_convrate;
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                return -ENODEV;
-        /*
+        /* detection and identification */
-         * Now we do the remaining detection. A negative kind means that
+        if ((man_id = i2c_smbus_read_byte_data(new_client,
-         * the driver was loaded with no force parameter (default), so we
-         * must both detect and identify the chip. A zero kind means that
-         * the driver was loaded with the force parameter, the detection
-         * step shall be skipped. A positive kind means that the driver
-         * was loaded with the force parameter and a given kind of chip is
-         * requested, so both the detection and the identification steps
-         * are skipped.
-         */
-        /* Default to an LM90 if forced */
-        if (kind == 0)
-                kind = lm90;
-        if (kind < 0) { /* detection and identification */
-                int man_id, chip_id, reg_config1, reg_convrate;
-                if ((man_id = i2c_smbus_read_byte_data(new_client,
                                                LM90_REG_R_MAN_ID)) < 0
-                 || (chip_id = i2c_smbus_read_byte_data(new_client,
+         || (chip_id = i2c_smbus_read_byte_data(new_client,
                                                LM90_REG_R_CHIP_ID)) < 0
-                 || (reg_config1 = i2c_smbus_read_byte_data(new_client,
+         || (reg_config1 = i2c_smbus_read_byte_data(new_client,
                                                LM90_REG_R_CONFIG1)) < 0
-                 || (reg_convrate = i2c_smbus_read_byte_data(new_client,
+         || (reg_convrate = i2c_smbus_read_byte_data(new_client,
                                                LM90_REG_R_CONVRATE)) < 0)
+                return -ENODEV;
+        if ((address == 0x4C || address == 0x4D)
+         && man_id == 0x01) { /* National Semiconductor */
+                int reg_config2;
+                reg_config2 = i2c_smbus_read_byte_data(new_client,
+                                                LM90_REG_R_CONFIG2);
+                if (reg_config2 < 0)
                        return -ENODEV;
-                
-                if ((address == 0x4C || address == 0x4D)
+                if ((reg_config1 & 0x2A) == 0x00
-                 && man_id == 0x01) { /* National Semiconductor */
+                 && (reg_config2 & 0xF8) == 0x00
-                        int reg_config2;
+                 && reg_convrate <= 0x09) {
+                        if (address == 0x4C
-                        if ((reg_config2 = i2c_smbus_read_byte_data(new_client,
+                         && (chip_id & 0xF0) == 0x20) { /* LM90 */
-                                                LM90_REG_R_CONFIG2)) < 0)
+                                name = "lm90";
-                                return -ENODEV;
-                        if ((reg_config1 & 0x2A) == 0x00
-                         && (reg_config2 & 0xF8) == 0x00
-                         && reg_convrate <= 0x09) {
-                                if (address == 0x4C
-                                 && (chip_id & 0xF0) == 0x20) { /* LM90 */
-                                        kind = lm90;
-                                } 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 */
-                                        kind = lm86;
-                                }
-                        }
-                } else
-                if ((address == 0x4C || address == 0x4D)
-                 && man_id == 0x41) { /* Analog Devices */
-                        if ((chip_id & 0xF0) == 0x40 /* ADM1032 */
-                         && (reg_config1 & 0x3F) == 0x00
-                         && reg_convrate <= 0x0A) {
-                                kind = adm1032;
-                        } else
-                        if (chip_id == 0x51 /* ADT7461 */
-                         && (reg_config1 & 0x1B) == 0x00
-                         && reg_convrate <= 0x0A) {
-                                kind = adt7461;
-                        }
-                } else
-                if (man_id == 0x4D) { /* Maxim */
-                        /*
-                         * The MAX6657, MAX6658 and MAX6659 do NOT have a
-                         * chip_id register. Reading from that address will
-                         * return the last read value, which in our case is
-                         * those of the man_id register. Likewise, the config1
-                         * register seems to lack a low nibble, so the value
-                         * will be those of the previous read, so in our case
-                         * those of the man_id register.
-                         */
-                        if (chip_id == man_id
-                         && (address == 0x4C || address == 0x4D)
-                         && (reg_config1 & 0x1F) == (man_id & 0x0F)
-                         && reg_convrate <= 0x09) {
-                                kind = max6657;
                        } else
-                        /* The chip_id register of the MAX6680 and MAX6681
+                        if ((chip_id & 0xF0) == 0x30) { /* LM89/LM99 */
-                         * holds the revision of the chip.
+                                name = "lm99";
-                         * the lowest bit of the config1 register is unused
+                                dev_info(&adapter->dev,
-                         * and should return zero when read, so should the
+                                         "Assuming LM99 chip at 0x%02x\n",
-                         * second to last bit of config1 (software reset)
+                                         address);
-                         */
+                                dev_info(&adapter->dev,
-                        if (chip_id == 0x01
+                                         "If it is an LM89, instantiate it "
-                         && (reg_config1 & 0x03) == 0x00
+                                         "with the new_device sysfs "
-                         && reg_convrate <= 0x07) {
+                                         "interface\n");
-                                kind = max6680;
                        } else
-                        /* The chip_id register of the MAX6646/6647/6649
+                        if (address == 0x4C
-                         * holds the revision of the chip.
+                         && (chip_id & 0xF0) == 0x10) { /* LM86 */
-                         * The lowest 6 bits of the config1 register are
+                                name = "lm86";
-                         * unused and should return zero when read.
-                         */
-                        if (chip_id == 0x59
-                         && (reg_config1 & 0x3f) == 0x00
-                         && reg_convrate <= 0x07) {
-                                kind = max6646;
                        }
                }
+        } else
-                if (kind <= 0) { /* identification failed */
+        if ((address == 0x4C || address == 0x4D)
-                        dev_dbg(&adapter->dev,
+         && man_id == 0x41) { /* Analog Devices */
-                                "Unsupported chip at 0x%02x (man_id=0x%02X, "
+                if ((chip_id & 0xF0) == 0x40 /* ADM1032 */
-                                "chip_id=0x%02X)\n", address, man_id, chip_id);
+                 && (reg_config1 & 0x3F) == 0x00
-                        return -ENODEV;
+                 && reg_convrate <= 0x0A) {
+                        name = "adm1032";
+                        /* The ADM1032 supports PEC, but only if combined
+                           transactions are not used. */
+                        if (i2c_check_functionality(adapter,
+                                                    I2C_FUNC_SMBUS_BYTE))
+                                info->flags |= I2C_CLIENT_PEC;
+                } else
+                if (chip_id == 0x51 /* ADT7461 */
+                 && (reg_config1 & 0x1B) == 0x00
+                 && reg_convrate <= 0x0A) {
+                        name = "adt7461";
+                }
+        } else
+        if (man_id == 0x4D) { /* Maxim */
+                /*
+                 * The MAX6657, MAX6658 and MAX6659 do NOT have a chip_id
+                 * register. Reading from that address will return the last
+                 * read value, which in our case is those of the man_id
+                 * register. Likewise, the config1 register seems to lack a
+                 * low nibble, so the value will be those of the previous
+                 * read, so in our case those of the man_id register.
+                 */
+                if (chip_id == man_id
+                 && (address == 0x4C || address == 0x4D)
+                 && (reg_config1 & 0x1F) == (man_id & 0x0F)
+                 && reg_convrate <= 0x09) {
+                        name = "max6657";
+                } else
+                /*
+                 * The chip_id register of the MAX6680 and MAX6681 holds the
+                 * revision of the chip. The lowest bit of the config1 register
+                 * is unused and should return zero when read, so should the
+                 * second to last bit of config1 (software reset).
+                 */
+                if (chip_id == 0x01
+                 && (reg_config1 & 0x03) == 0x00
+                 && reg_convrate <= 0x07) {
+                        name = "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) {
+                        name = "max6646";
                }
        }
-        /* Fill the i2c board info */
+        if (!name) { /* identification failed */
-        if (kind == lm90) {
+                dev_dbg(&adapter->dev,
-                name = "lm90";
+                        "Unsupported chip at 0x%02x (man_id=0x%02X, "
-        } else if (kind == adm1032) {
+                        "chip_id=0x%02X)\n", address, man_id, chip_id);
-                name = "adm1032";
+                return -ENODEV;
-                /* The ADM1032 supports PEC, but only if combined
-                   transactions are not used. */
-                if (i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
-                        info->flags |= I2C_CLIENT_PEC;
-        } else if (kind == lm99) {
-                name = "lm99";
-        } else if (kind == lm86) {
-                name = "lm86";
-        } else if (kind == max6657) {
-                name = "max6657";
-        } else if (kind == max6680) {
-                name = "max6680";
-        } else if (kind == adt7461) {
-                name = "adt7461";
-        } else if (kind == max6646) {
-                name = "max6646";
        }
        strlcpy(info->type, name, I2C_NAME_SIZE);
        return 0;
diff --git a/drivers/hwmon/lm92.c b/drivers/hwmon/lm92.c
index b2e00c5a7eec..47ac698709dc 100644
--- a/drivers/hwmon/lm92.c
+++ b/drivers/hwmon/lm92.c
@@ -323,31 +323,22 @@ static int lm92_detect(struct i2c_client *new_client, int kind,
                       struct i2c_board_info *info)
 {
        struct i2c_adapter *adapter = new_client->adapter;
+        u8 config;
+        u16 man_id;
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA
                                            | I2C_FUNC_SMBUS_WORD_DATA))
                return -ENODEV;
-        /* A negative kind means that the driver was loaded with no force
+        config = i2c_smbus_read_byte_data(new_client, LM92_REG_CONFIG);
-           parameter (default), so we must identify the chip. */
+        man_id = i2c_smbus_read_word_data(new_client, LM92_REG_MAN_ID);
-        if (kind < 0) {
-                u8 config = i2c_smbus_read_byte_data(new_client,
+        if ((config & 0xe0) == 0x00 && man_id == 0x0180)
-                             LM92_REG_CONFIG);
+                pr_info("lm92: Found National Semiconductor LM92 chip\n");
-                u16 man_id = i2c_smbus_read_word_data(new_client,
+        else if (max6635_check(new_client))
-                             LM92_REG_MAN_ID);
+                pr_info("lm92: Found Maxim MAX6635 chip\n");
+        else
-                if ((config & 0xe0) == 0x00
+                return -ENODEV;
-                 && man_id == 0x0180) {
-                        pr_info("lm92: Found National Semiconductor LM92 chip\n");
-                        kind = lm92;
-                } else
-                if (max6635_check(new_client)) {
-                        pr_info("lm92: Found Maxim MAX6635 chip\n");
-                        kind = lm92; /* No separate prefix */
-                }
-                else
-                        return -ENODEV;
-        }
        strlcpy(info->type, "lm92", I2C_NAME_SIZE);
diff --git a/drivers/hwmon/lm93.c b/drivers/hwmon/lm93.c
index c48a284b8314..124dd7cea54c 100644
--- a/drivers/hwmon/lm93.c
+++ b/drivers/hwmon/lm93.c
@@ -2505,34 +2505,24 @@ static int lm93_detect(struct i2c_client *client, int kind,
                       struct i2c_board_info *info)
 {
        struct i2c_adapter *adapter = client->adapter;
+        int mfr, ver;
        if (!i2c_check_functionality(adapter, LM93_SMBUS_FUNC_MIN))
                return -ENODEV;
        /* detection */
-        if (kind < 0) {
+        mfr = lm93_read_byte(client, LM93_REG_MFR_ID);
-                int mfr = lm93_read_byte(client, LM93_REG_MFR_ID);
+        if (mfr != 0x01) {
+                dev_dbg(&adapter->dev,
-                if (mfr != 0x01) {
+                        "detect failed, bad manufacturer id 0x%02x!\n", mfr);
-                        dev_dbg(&adapter->dev,"detect failed, "
+                return -ENODEV;
-                                "bad manufacturer id 0x%02x!\n", mfr);
-                        return -ENODEV;
-                }
        }
-        if (kind <= 0) {
+        ver = lm93_read_byte(client, LM93_REG_VER);
-                int ver = lm93_read_byte(client, LM93_REG_VER);
+        if (ver != LM93_MFR_ID && ver != LM93_MFR_ID_PROTOTYPE) {
+                dev_dbg(&adapter->dev,
-                if ((ver == LM93_MFR_ID) || (ver == LM93_MFR_ID_PROTOTYPE)) {
+                        "detect failed, bad version id 0x%02x!\n", ver);
-                        kind = lm93;
+                return -ENODEV;
-                } else {
-                        dev_dbg(&adapter->dev,"detect failed, "
-                                "bad version id 0x%02x!\n", ver);
-                        if (kind == 0)
-                                dev_dbg(&adapter->dev,
-                                        "(ignored 'force' parameter)\n");
-                        return -ENODEV;
-                }
        }
        strlcpy(info->type, "lm93", I2C_NAME_SIZE);
diff --git a/drivers/hwmon/lm95241.c b/drivers/hwmon/lm95241.c
index e34f9e402a2c..906b896cf1d0 100644
--- a/drivers/hwmon/lm95241.c
+++ b/drivers/hwmon/lm95241.c
@@ -315,51 +315,23 @@ static int lm95241_detect(struct i2c_client *new_client, int kind,
 {
        struct i2c_adapter *adapter = new_client->adapter;
        int address = new_client->addr;
-        const char *name = "";
+        const char *name;
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                return -ENODEV;
-        /*
+        if ((i2c_smbus_read_byte_data(new_client, LM95241_REG_R_MAN_ID)
-         * Now we do the remaining detection. A negative kind means that
+             == MANUFACTURER_ID)
-         * the driver was loaded with no force parameter (default), so we
+         && (i2c_smbus_read_byte_data(new_client, LM95241_REG_R_CHIP_ID)
-         * must both detect and identify the chip. A zero kind means that
+             >= DEFAULT_REVISION)) {
-         * the driver was loaded with the force parameter, the detection
+                name = "lm95241";
-         * step shall be skipped. A positive kind means that the driver
+        } else {
-         * was loaded with the force parameter and a given kind of chip is
+                dev_dbg(&adapter->dev, "LM95241 detection failed at 0x%02x\n",
-         * requested, so both the detection and the identification steps
+                        address);
-         * are skipped.
+                return -ENODEV;
-         */
-        if (kind < 0) { /* detection */
-                if ((i2c_smbus_read_byte_data(new_client, LM95241_REG_R_MAN_ID)
-                     != MANUFACTURER_ID)
-                || (i2c_smbus_read_byte_data(new_client, LM95241_REG_R_CHIP_ID)
-                    < DEFAULT_REVISION)) {
-                        dev_dbg(&adapter->dev,
-                                "LM95241 detection failed at 0x%02x.\n",
-                                address);
-                        return -ENODEV;
-                }
-        }
-        if (kind <= 0) { /* identification */
-                if ((i2c_smbus_read_byte_data(new_client, LM95241_REG_R_MAN_ID)
-                     == MANUFACTURER_ID)
-                && (i2c_smbus_read_byte_data(new_client, LM95241_REG_R_CHIP_ID)
-                    >= DEFAULT_REVISION)) {
-                        kind = lm95241;
-                        if (kind <= 0) { /* identification failed */
-                                dev_info(&adapter->dev, "Unsupported chip\n");
-                                return -ENODEV;
-                        }
-                }
        }
        /* Fill the i2c board info */
-        if (kind == lm95241)
-                name = "lm95241";
        strlcpy(info->type, name, I2C_NAME_SIZE);
        return 0;
 }
diff --git a/drivers/hwmon/max1619.c b/drivers/hwmon/max1619.c
index 7897754f3a5c..7fcf5ff89e7f 100644
--- a/drivers/hwmon/max1619.c
+++ b/drivers/hwmon/max1619.c
@@ -226,58 +226,34 @@ static const struct attribute_group max1619_group = {
 */
 /* Return 0 if detection is successful, -ENODEV otherwise */
-static int max1619_detect(struct i2c_client *new_client, int kind,
+static int max1619_detect(struct i2c_client *client, int kind,
                          struct i2c_board_info *info)
 {
-        struct i2c_adapter *adapter = new_client->adapter;
+        struct i2c_adapter *adapter = client->adapter;
-        u8 reg_config=0, reg_convrate=0, reg_status=0;
+        u8 reg_config, reg_convrate, reg_status, man_id, chip_id;
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                return -ENODEV;
-        /*
+        /* detection */
-         * Now we do the remaining detection. A negative kind means that
+        reg_config = i2c_smbus_read_byte_data(client, MAX1619_REG_R_CONFIG);
-         * the driver was loaded with no force parameter (default), so we
+        reg_convrate = i2c_smbus_read_byte_data(client, MAX1619_REG_R_CONVRATE);
-         * must both detect and identify the chip. A zero kind means that
+        reg_status = i2c_smbus_read_byte_data(client, MAX1619_REG_R_STATUS);
-         * the driver was loaded with the force parameter, the detection
+        if ((reg_config & 0x03) != 0x00
-         * step shall be skipped. A positive kind means that the driver
+         || reg_convrate > 0x07 || (reg_status & 0x61) != 0x00) {
-         * was loaded with the force parameter and a given kind of chip is
+                dev_dbg(&adapter->dev, "MAX1619 detection failed at 0x%02x\n",
-         * requested, so both the detection and the identification steps
+                        client->addr);
-         * are skipped.
+                return -ENODEV;
-         */
-        if (kind < 0) { /* detection */
-                reg_config = i2c_smbus_read_byte_data(new_client,
-                              MAX1619_REG_R_CONFIG);
-                reg_convrate = i2c_smbus_read_byte_data(new_client,
-                               MAX1619_REG_R_CONVRATE);
-                reg_status = i2c_smbus_read_byte_data(new_client,
-                                MAX1619_REG_R_STATUS);
-                if ((reg_config & 0x03) != 0x00
-                 || reg_convrate > 0x07 || (reg_status & 0x61 ) !=0x00) {
-                        dev_dbg(&adapter->dev,
-                                "MAX1619 detection failed at 0x%02x.\n",
-                                new_client->addr);
-                        return -ENODEV;
-                }
        }
-        if (kind <= 0) { /* identification */
+        /* identification */
-                u8 man_id, chip_id;
+        man_id = i2c_smbus_read_byte_data(client, MAX1619_REG_R_MAN_ID);
-        
+        chip_id = i2c_smbus_read_byte_data(client, MAX1619_REG_R_CHIP_ID);
-                man_id = i2c_smbus_read_byte_data(new_client,
+        if (man_id != 0x4D || chip_id != 0x04) {
-                         MAX1619_REG_R_MAN_ID);
+                dev_info(&adapter->dev,
-                chip_id = i2c_smbus_read_byte_data(new_client,
+                         "Unsupported chip (man_id=0x%02X, chip_id=0x%02X).\n",
-                          MAX1619_REG_R_CHIP_ID);
+                         man_id, chip_id);
-                
+                return -ENODEV;
-                if ((man_id == 0x4D) && (chip_id == 0x04))
-                        kind = max1619;
-                if (kind <= 0) { /* identification failed */
-                        dev_info(&adapter->dev,
-                            "Unsupported chip (man_id=0x%02X, "
-                            "chip_id=0x%02X).\n", man_id, chip_id);
-                        return -ENODEV;
-                }
        }
        strlcpy(info->type, "max1619", I2C_NAME_SIZE);
diff --git a/drivers/hwmon/max6650.c b/drivers/hwmon/max6650.c
index 58f66be61b1f..1da561e0cb37 100644
--- a/drivers/hwmon/max6650.c
+++ b/drivers/hwmon/max6650.c
@@ -534,7 +534,7 @@ static int max6650_detect(struct i2c_client *client, int kind,
        struct i2c_adapter *adapter = client->adapter;
        int address = client->addr;
-        dev_dbg(&adapter->dev, "max6650_detect called, kind = %d\n", kind);
+        dev_dbg(&adapter->dev, "max6650_detect called\n");
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
                dev_dbg(&adapter->dev, "max6650: I2C bus doesn't support "
@@ -542,23 +542,7 @@ static int max6650_detect(struct i2c_client *client, int kind,
                return -ENODEV;
        }
-        /*
+        if (((i2c_smbus_read_byte_data(client, MAX6650_REG_CONFIG) & 0xC0)
-         * Now we do the remaining detection. A negative kind means that
-         * the driver was loaded with no force parameter (default), so we
-         * must both detect and identify the chip (actually there is only
-         * one possible kind of chip for now, max6650). A zero kind means that
-         * the driver was loaded with the force parameter, the detection
-         * step shall be skipped. A positive kind means that the driver
-         * was loaded with the force parameter and a given kind of chip is
-         * requested, so both the detection and the identification steps
-         * are skipped.
-         *
-         * Currently I can find no way to distinguish between a MAX6650 and
-         * a MAX6651. This driver has only been tried on the former.
-         */
-        if ((kind < 0) &&
-           (  (i2c_smbus_read_byte_data(client, MAX6650_REG_CONFIG) & 0xC0)
            ||(i2c_smbus_read_byte_data(client, MAX6650_REG_GPIO_STAT) & 0xE0)
            ||(i2c_smbus_read_byte_data(client, MAX6650_REG_ALARM_EN) & 0xE0)
            ||(i2c_smbus_read_byte_data(client, MAX6650_REG_ALARM) & 0xE0)
diff --git a/drivers/hwmon/mc13783-adc.c b/drivers/hwmon/mc13783-adc.c
new file mode 100644
index 000000000000..883fa8197da4
--- /dev/null
+++ b/drivers/hwmon/mc13783-adc.c
@@ -0,0 +1,236 @@
+/*
+ * Driver for the Freescale Semiconductor MC13783 adc.
+ *
+ * Copyright 2004-2007 Freescale Semiconductor, Inc. All Rights Reserved.
+ * Copyright (C) 2009 Sascha Hauer, Pengutronix
+ *
+ * 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., 51
+ * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+#include <linux/mfd/mc13783-private.h>
+#include <linux/platform_device.h>
+#include <linux/hwmon-sysfs.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/hwmon.h>
+#include <linux/init.h>
+#include <linux/err.h>
+#define MC13783_ADC_NAME        "mc13783-adc"
+struct mc13783_adc_priv {
+        struct mc13783 *mc13783;
+        struct device *hwmon_dev;
+};
+static ssize_t mc13783_adc_show_name(struct device *dev, struct device_attribute
+                              *devattr, char *buf)
+{
+        return sprintf(buf, "mc13783_adc\n");
+}
+static int mc13783_adc_read(struct device *dev,
+                struct device_attribute *devattr, unsigned int *val)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct mc13783_adc_priv *priv = platform_get_drvdata(pdev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        unsigned int channel = attr->index;
+        unsigned int sample[4];
+        int ret;
+        ret = mc13783_adc_do_conversion(priv->mc13783,
+                        MC13783_ADC_MODE_MULT_CHAN,
+                        channel, sample);
+        if (ret)
+                return ret;
+        channel &= 0x7;
+        *val = (sample[channel % 4] >> (channel > 3 ? 14 : 2)) & 0x3ff;
+        return 0;
+}
+static ssize_t mc13783_adc_read_bp(struct device *dev,
+                struct device_attribute *devattr, char *buf)
+{
+        unsigned val;
+        int ret = mc13783_adc_read(dev, devattr, &val);
+        if (ret)
+                return ret;
+        /*
+         * BP (channel 2) reports with offset 2.4V to the actual value to fit
+         * the input range of the ADC.  unit = 2.25mV = 9/4 mV.
+         */
+        val = DIV_ROUND_CLOSEST(val * 9, 4) + 2400;
+        return sprintf(buf, "%u\n", val);
+}
+static ssize_t mc13783_adc_read_gp(struct device *dev,
+                struct device_attribute *devattr, char *buf)
+{
+        unsigned val;
+        int ret = mc13783_adc_read(dev, devattr, &val);
+        if (ret)
+                return ret;
+        /*
+         * input range is [0, 2.3V], val has 10 bits, so each bit
+         * is worth 9/4 mV.
+         */
+        val = DIV_ROUND_CLOSEST(val * 9, 4);
+        return sprintf(buf, "%u\n", val);
+}
+static DEVICE_ATTR(name, S_IRUGO, mc13783_adc_show_name, NULL);
+static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, mc13783_adc_read_bp, NULL, 2);
+static SENSOR_DEVICE_ATTR(in5_input, S_IRUGO, mc13783_adc_read_gp, NULL, 5);
+static SENSOR_DEVICE_ATTR(in6_input, S_IRUGO, mc13783_adc_read_gp, NULL, 6);
+static SENSOR_DEVICE_ATTR(in7_input, S_IRUGO, mc13783_adc_read_gp, NULL, 7);
+static SENSOR_DEVICE_ATTR(in8_input, S_IRUGO, mc13783_adc_read_gp, NULL, 8);
+static SENSOR_DEVICE_ATTR(in9_input, S_IRUGO, mc13783_adc_read_gp, NULL, 9);
+static SENSOR_DEVICE_ATTR(in10_input, S_IRUGO, mc13783_adc_read_gp, NULL, 10);
+static SENSOR_DEVICE_ATTR(in11_input, S_IRUGO, mc13783_adc_read_gp, NULL, 11);
+static SENSOR_DEVICE_ATTR(in12_input, S_IRUGO, mc13783_adc_read_gp, NULL, 12);
+static SENSOR_DEVICE_ATTR(in13_input, S_IRUGO, mc13783_adc_read_gp, NULL, 13);
+static SENSOR_DEVICE_ATTR(in14_input, S_IRUGO, mc13783_adc_read_gp, NULL, 14);
+static SENSOR_DEVICE_ATTR(in15_input, S_IRUGO, mc13783_adc_read_gp, NULL, 15);
+static struct attribute *mc13783_attr[] = {
+        &dev_attr_name.attr,
+        &sensor_dev_attr_in2_input.dev_attr.attr,
+        &sensor_dev_attr_in5_input.dev_attr.attr,
+        &sensor_dev_attr_in6_input.dev_attr.attr,
+        &sensor_dev_attr_in7_input.dev_attr.attr,
+        &sensor_dev_attr_in8_input.dev_attr.attr,
+        &sensor_dev_attr_in9_input.dev_attr.attr,
+        &sensor_dev_attr_in10_input.dev_attr.attr,
+        &sensor_dev_attr_in11_input.dev_attr.attr,
+        NULL
+};
+static const struct attribute_group mc13783_group = {
+        .attrs = mc13783_attr,
+};
+/* last four channels may be occupied by the touchscreen */
+static struct attribute *mc13783_attr_ts[] = {
+        &sensor_dev_attr_in12_input.dev_attr.attr,
+        &sensor_dev_attr_in13_input.dev_attr.attr,
+        &sensor_dev_attr_in14_input.dev_attr.attr,
+        &sensor_dev_attr_in15_input.dev_attr.attr,
+        NULL
+};
+static const struct attribute_group mc13783_group_ts = {
+        .attrs = mc13783_attr_ts,
+};
+static int __init mc13783_adc_probe(struct platform_device *pdev)
+{
+        struct mc13783_adc_priv *priv;
+        int ret;
+        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        if (!priv)
+                return -ENOMEM;
+        priv->mc13783 = dev_get_drvdata(pdev->dev.parent);
+        platform_set_drvdata(pdev, priv);
+        /* Register sysfs hooks */
+        ret = sysfs_create_group(&pdev->dev.kobj, &mc13783_group);
+        if (ret)
+                goto out_err_create1;
+        if (!(priv->mc13783->flags & MC13783_USE_TOUCHSCREEN))
+                ret = sysfs_create_group(&pdev->dev.kobj, &mc13783_group_ts);
+                if (ret)
+                        goto out_err_create2;
+        priv->hwmon_dev = hwmon_device_register(&pdev->dev);
+        if (IS_ERR(priv->hwmon_dev)) {
+                ret = PTR_ERR(priv->hwmon_dev);
+                dev_err(&pdev->dev,
+                                "hwmon_device_register failed with %d.\n", ret);
+                goto out_err_register;
+        }
+        return 0;
+out_err_register:
+        if (!(priv->mc13783->flags & MC13783_USE_TOUCHSCREEN))
+                sysfs_remove_group(&pdev->dev.kobj, &mc13783_group_ts);
+out_err_create2:
+        sysfs_remove_group(&pdev->dev.kobj, &mc13783_group);
+out_err_create1:
+        platform_set_drvdata(pdev, NULL);
+        kfree(priv);
+        return ret;
+}
+static int __devexit mc13783_adc_remove(struct platform_device *pdev)
+{
+        struct mc13783_adc_priv *priv = platform_get_drvdata(pdev);
+        hwmon_device_unregister(priv->hwmon_dev);
+        if (!(priv->mc13783->flags & MC13783_USE_TOUCHSCREEN))
+                sysfs_remove_group(&pdev->dev.kobj, &mc13783_group_ts);
+        sysfs_remove_group(&pdev->dev.kobj, &mc13783_group);
+        platform_set_drvdata(pdev, NULL);
+        kfree(priv);
+        return 0;
+}
+static struct platform_driver mc13783_adc_driver = {
+        .remove         = __devexit_p(mc13783_adc_remove),
+        .driver         = {
+                .owner  = THIS_MODULE,
+                .name   = MC13783_ADC_NAME,
+        },
+};
+static int __init mc13783_adc_init(void)
+{
+        return platform_driver_probe(&mc13783_adc_driver, mc13783_adc_probe);
+}
+static void __exit mc13783_adc_exit(void)
+{
+        platform_driver_unregister(&mc13783_adc_driver);
+}
+module_init(mc13783_adc_init);
+module_exit(mc13783_adc_exit);
+MODULE_DESCRIPTION("MC13783 ADC driver");
+MODULE_AUTHOR("Luotao Fu <l.fu@pengutronix.de>");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:" MC13783_ADC_NAME);
diff --git a/drivers/hwmon/s3c-hwmon.c b/drivers/hwmon/s3c-hwmon.c
index 71835412529f..3f3f9a47acfd 100644
--- a/drivers/hwmon/s3c-hwmon.c
+++ b/drivers/hwmon/s3c-hwmon.c
@@ -323,7 +323,7 @@ static int __devinit s3c_hwmon_probe(struct platform_device *dev)
        }
        for (i = 0; i < ARRAY_SIZE(pdata->in); i++) {
-                struct s3c24xx_adc_hwmon_incfg *cfg = pdata->in[i];
+                struct s3c_hwmon_chcfg *cfg = pdata->in[i];
                if (!cfg)
                        continue;
@@ -333,7 +333,7 @@ static int __devinit s3c_hwmon_probe(struct platform_device *dev)
                                 "channel %d multiplier too large\n",
                                 i);
-                if (cfg->divider == 0) {
+                if (cfg->div == 0) {
                        dev_err(&dev->dev, "channel %d divider zero\n", i);
                        continue;
                }
diff --git a/drivers/hwmon/smsc47m192.c b/drivers/hwmon/smsc47m192.c
index 8bb5cb532d4d..4d88c045781c 100644
--- a/drivers/hwmon/smsc47m192.c
+++ b/drivers/hwmon/smsc47m192.c
@@ -491,24 +491,22 @@ static int smsc47m192_detect(struct i2c_client *client, int kind,
                return -ENODEV;
        /* Detection criteria from sensors_detect script */
-        if (kind < 0) {
+        version = i2c_smbus_read_byte_data(client, SMSC47M192_REG_VERSION);
-                if (i2c_smbus_read_byte_data(client,
+        if (i2c_smbus_read_byte_data(client,
                                SMSC47M192_REG_COMPANY_ID) == 0x55
-                 && ((version = i2c_smbus_read_byte_data(client,
+         && (version & 0xf0) == 0x20
-                                SMSC47M192_REG_VERSION)) & 0xf0) == 0x20
+         && (i2c_smbus_read_byte_data(client,
-                 && (i2c_smbus_read_byte_data(client,
                                SMSC47M192_REG_VID) & 0x70) == 0x00
-                 && (i2c_smbus_read_byte_data(client,
+         && (i2c_smbus_read_byte_data(client,
                                SMSC47M192_REG_VID4) & 0xfe) == 0x80) {
-                        dev_info(&adapter->dev,
+                dev_info(&adapter->dev,
-                                 "found SMSC47M192 or compatible, "
+                         "found SMSC47M192 or compatible, "
-                                 "version 2, stepping A%d\n", version & 0x0f);
+                         "version 2, stepping A%d\n", version & 0x0f);
-                } else {
+        } else {
-                        dev_dbg(&adapter->dev,
+                dev_dbg(&adapter->dev,
-                                "SMSC47M192 detection failed at 0x%02x\n",
+                        "SMSC47M192 detection failed at 0x%02x\n",
-                                client->addr);
+                        client->addr);
-                        return -ENODEV;
+                return -ENODEV;
-                }
        }
        strlcpy(info->type, "smsc47m192", I2C_NAME_SIZE);
diff --git a/drivers/hwmon/thmc50.c b/drivers/hwmon/thmc50.c
index 7d97431e132f..4b793849c738 100644
--- a/drivers/hwmon/thmc50.c
+++ b/drivers/hwmon/thmc50.c
@@ -36,7 +36,11 @@ static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
 /* Insmod parameters */
 I2C_CLIENT_INSMOD_2(thmc50, adm1022);
-I2C_CLIENT_MODULE_PARM(adm1022_temp3, "List of adapter,address pairs "
+static unsigned short adm1022_temp3[16];
+static unsigned int adm1022_temp3_num;
+module_param_array(adm1022_temp3, ushort, &adm1022_temp3_num, 0);
+MODULE_PARM_DESC(adm1022_temp3, "List of adapter,address pairs "
                        "to enable 3rd temperature (ADM1022 only)");
 /* Many THMC50 constants specified below */
@@ -289,7 +293,6 @@ static int thmc50_detect(struct i2c_client *client, int kind,
        unsigned revision;
        unsigned config;
        struct i2c_adapter *adapter = client->adapter;
-        int err = 0;
        const char *type_name;
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
@@ -301,31 +304,13 @@ static int thmc50_detect(struct i2c_client *client, int kind,
        pr_debug("thmc50: Probing for THMC50 at 0x%2X on bus %d\n",
                 client->addr, i2c_adapter_id(client->adapter));
-        /* Now, we do the remaining detection. */
        company = i2c_smbus_read_byte_data(client, THMC50_REG_COMPANY_ID);
        revision = i2c_smbus_read_byte_data(client, THMC50_REG_DIE_CODE);
        config = i2c_smbus_read_byte_data(client, THMC50_REG_CONF);
+        if (revision < 0xc0 || (config & 0x10))
+                return -ENODEV;
-        if (kind == 0)
+        if (company == 0x41) {
-                kind = thmc50;
-        else if (kind < 0) {
-                err = -ENODEV;
-                if (revision >= 0xc0 && ((config & 0x10) == 0)) {
-                        if (company == 0x49) {
-                                kind = thmc50;
-                                err = 0;
-                        } else if (company == 0x41) {
-                                kind = adm1022;
-                                err = 0;
-                        }
-                }
-        }
-        if (err == -ENODEV) {
-                pr_debug("thmc50: Detection of THMC50/ADM1022 failed\n");
-                return err;
-        }
-        if (kind == adm1022) {
                int id = i2c_adapter_id(client->adapter);
                int i;
@@ -340,9 +325,13 @@ static int thmc50_detect(struct i2c_client *client, int kind,
                                                          config);
                                break;
                        }
-        } else {
+        } else if (company == 0x49) {
                type_name = "thmc50";
+        } else {
+                pr_debug("thmc50: Detection of THMC50/ADM1022 failed\n");
+                return -ENODEV;
        }
        pr_debug("thmc50: Detected %s (version %x, revision %x)\n",
                 type_name, (revision >> 4) - 0xc, revision & 0xf);
diff --git a/drivers/hwmon/tmp401.c b/drivers/hwmon/tmp401.c
index 7b34f2cd08bb..ee9673467c4a 100644
--- a/drivers/hwmon/tmp401.c
+++ b/drivers/hwmon/tmp401.c
@@ -488,46 +488,43 @@ static void tmp401_init_client(struct i2c_client *client)
                i2c_smbus_write_byte_data(client, TMP401_CONFIG_WRITE, config);
 }
-static int tmp401_detect(struct i2c_client *client, int kind,
+static int tmp401_detect(struct i2c_client *client, int _kind,
                         struct i2c_board_info *info)
 {
+        enum chips kind;
        struct i2c_adapter *adapter = client->adapter;
+        u8 reg;
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                return -ENODEV;
        /* Detect and identify the chip */
-        if (kind <= 0) {
+        reg = i2c_smbus_read_byte_data(client, TMP401_MANUFACTURER_ID_REG);
-                u8 reg;
+        if (reg != TMP401_MANUFACTURER_ID)
+                return -ENODEV;
-                reg = i2c_smbus_read_byte_data(client,
-                                               TMP401_MANUFACTURER_ID_REG);
-                if (reg != TMP401_MANUFACTURER_ID)
-                        return -ENODEV;
-                reg = i2c_smbus_read_byte_data(client, TMP401_DEVICE_ID_REG);
-                switch (reg) {
-                case TMP401_DEVICE_ID:
-                        kind = tmp401;
-                        break;
-                case TMP411_DEVICE_ID:
-                        kind = tmp411;
-                        break;
-                default:
-                        return -ENODEV;
-                }
-                reg = i2c_smbus_read_byte_data(client, TMP401_CONFIG_READ);
+        reg = i2c_smbus_read_byte_data(client, TMP401_DEVICE_ID_REG);
-                if (reg & 0x1b)
-                        return -ENODEV;
-                reg = i2c_smbus_read_byte_data(client,
+        switch (reg) {
-                                               TMP401_CONVERSION_RATE_READ);
+        case TMP401_DEVICE_ID:
-                /* Datasheet says: 0x1-0x6 */
+                kind = tmp401;
-                if (reg > 15)
+                break;
-                        return -ENODEV;
+        case TMP411_DEVICE_ID:
+                kind = tmp411;
+                break;
+        default:
+                return -ENODEV;
        }
+        reg = i2c_smbus_read_byte_data(client, TMP401_CONFIG_READ);
+        if (reg & 0x1b)
+                return -ENODEV;
+        reg = i2c_smbus_read_byte_data(client, TMP401_CONVERSION_RATE_READ);
+        /* Datasheet says: 0x1-0x6 */
+        if (reg > 15)
+                return -ENODEV;
        strlcpy(info->type, tmp401_id[kind - 1].name, I2C_NAME_SIZE);
        return 0;
diff --git a/drivers/hwmon/tmp421.c b/drivers/hwmon/tmp421.c
index 20924343431b..bb5464a289ca 100644
--- a/drivers/hwmon/tmp421.c
+++ b/drivers/hwmon/tmp421.c
@@ -223,39 +223,36 @@ static int tmp421_init_client(struct i2c_client *client)
        return 0;
 }
-static int tmp421_detect(struct i2c_client *client, int kind,
+static int tmp421_detect(struct i2c_client *client, int _kind,
                         struct i2c_board_info *info)
 {
+        enum chips kind;
        struct i2c_adapter *adapter = client->adapter;
        const char *names[] = { "TMP421", "TMP422", "TMP423" };
+        u8 reg;
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                return -ENODEV;
-        if (kind <= 0) {
+        reg = i2c_smbus_read_byte_data(client, TMP421_MANUFACTURER_ID_REG);
-                u8 reg;
+        if (reg != TMP421_MANUFACTURER_ID)
+                return -ENODEV;
-                reg = i2c_smbus_read_byte_data(client,
-                                               TMP421_MANUFACTURER_ID_REG);
+        reg = i2c_smbus_read_byte_data(client, TMP421_DEVICE_ID_REG);
-                if (reg != TMP421_MANUFACTURER_ID)
+        switch (reg) {
-                        return -ENODEV;
+        case TMP421_DEVICE_ID:
+                kind = tmp421;
-                reg = i2c_smbus_read_byte_data(client,
+                break;
-                                               TMP421_DEVICE_ID_REG);
+        case TMP422_DEVICE_ID:
-                switch (reg) {
+                kind = tmp422;
-                case TMP421_DEVICE_ID:
+                break;
-                        kind = tmp421;
+        case TMP423_DEVICE_ID:
-                        break;
+                kind = tmp423;
-                case TMP422_DEVICE_ID:
+                break;
-                        kind = tmp422;
+        default:
-                        break;
+                return -ENODEV;
-                case TMP423_DEVICE_ID:
-                        kind = tmp423;
-                        break;
-                default:
-                        return -ENODEV;
-                }
        }
        strlcpy(info->type, tmp421_id[kind - 1].name, I2C_NAME_SIZE);
        dev_info(&adapter->dev, "Detected TI %s chip at 0x%02x\n",
                 names[kind - 1], client->addr);
diff --git a/drivers/hwmon/w83627hf.c b/drivers/hwmon/w83627hf.c
index 2be28ac4ede0..b257c7223733 100644
--- a/drivers/hwmon/w83627hf.c
+++ b/drivers/hwmon/w83627hf.c
@@ -59,10 +59,11 @@ static struct platform_device *pdev;
 #define DRVNAME "w83627hf"
 enum chips { w83627hf, w83627thf, w83697hf, w83637hf, w83687thf };
-static u16 force_addr;
+struct w83627hf_sio_data {
-module_param(force_addr, ushort, 0);
+        enum chips type;
-MODULE_PARM_DESC(force_addr,
+        int sioaddr;
-                 "Initialize the base address of the sensors");
+};
 static u8 force_i2c = 0x1f;
 module_param(force_i2c, byte, 0);
 MODULE_PARM_DESC(force_i2c,
@@ -77,9 +78,7 @@ module_param(force_id, ushort, 0);
 MODULE_PARM_DESC(force_id, "Override the detected device ID");
 /* modified from kernel/include/traps.c */
-static int REG;         /* The register to read/write */
 #define DEV     0x07    /* Register: Logical device select */
-static int VAL;         /* The value to read/write */
 /* logical device numbers for superio_select (below) */
 #define W83627HF_LD_FDC         0x00
@@ -109,37 +108,37 @@ static int VAL;		/* The value to read/write */
 #define W83687THF_VID_DATA      0xF1 /* w83687thf only */
 static inline void
-superio_outb(int reg, int val)
+superio_outb(struct w83627hf_sio_data *sio, int reg, int val)
 {
-        outb(reg, REG);
+        outb(reg, sio->sioaddr);
-        outb(val, VAL);
+        outb(val, sio->sioaddr + 1);
 }
 static inline int
-superio_inb(int reg)
+superio_inb(struct w83627hf_sio_data *sio, int reg)
 {
-        outb(reg, REG);
+        outb(reg, sio->sioaddr);
-        return inb(VAL);
+        return inb(sio->sioaddr + 1);
 }
 static inline void
-superio_select(int ld)
+superio_select(struct w83627hf_sio_data *sio, int ld)
 {
-        outb(DEV, REG);
+        outb(DEV, sio->sioaddr);
-        outb(ld, VAL);
+        outb(ld,  sio->sioaddr + 1);
 }
 static inline void
-superio_enter(void)
+superio_enter(struct w83627hf_sio_data *sio)
 {
-        outb(0x87, REG);
+        outb(0x87, sio->sioaddr);
-        outb(0x87, REG);
+        outb(0x87, sio->sioaddr);
 }
 static inline void
-superio_exit(void)
+superio_exit(struct w83627hf_sio_data *sio)
 {
-        outb(0xAA, REG);
+        outb(0xAA, sio->sioaddr);
 }
 #define W627_DEVID 0x52
@@ -380,10 +379,6 @@ struct w83627hf_data {
        u8 vrm_ovt;             /* Register value, 627THF/637HF/687THF only */
 };
-struct w83627hf_sio_data {
-        enum chips type;
-};
 static int w83627hf_probe(struct platform_device *pdev);
 static int __devexit w83627hf_remove(struct platform_device *pdev);
@@ -1140,11 +1135,8 @@ static int __init w83627hf_find(int sioaddr, unsigned short *addr,
                "W83687THF",
        };
-        REG = sioaddr;
+        superio_enter(sio_data);
-        VAL = sioaddr + 1;
+        val = force_id ? force_id : superio_inb(sio_data, DEVID);
-        superio_enter();
-        val = force_id ? force_id : superio_inb(DEVID);
        switch (val) {
        case W627_DEVID:
                sio_data->type = w83627hf;
@@ -1168,16 +1160,9 @@ static int __init w83627hf_find(int sioaddr, unsigned short *addr,
                goto exit;
        }
-        superio_select(W83627HF_LD_HWM);
+        superio_select(sio_data, W83627HF_LD_HWM);
-        force_addr &= WINB_ALIGNMENT;
+        val = (superio_inb(sio_data, WINB_BASE_REG) << 8) |
-        if (force_addr) {
+               superio_inb(sio_data, WINB_BASE_REG + 1);
-                printk(KERN_WARNING DRVNAME ": Forcing address 0x%x\n",
-                       force_addr);
-                superio_outb(WINB_BASE_REG, force_addr >> 8);
-                superio_outb(WINB_BASE_REG + 1, force_addr & 0xff);
-        }
-        val = (superio_inb(WINB_BASE_REG) << 8) |
-               superio_inb(WINB_BASE_REG + 1);
        *addr = val & WINB_ALIGNMENT;
        if (*addr == 0) {
                printk(KERN_WARNING DRVNAME ": Base address not set, "
@@ -1185,18 +1170,19 @@ static int __init w83627hf_find(int sioaddr, unsigned short *addr,
                goto exit;
        }
-        val = superio_inb(WINB_ACT_REG);
+        val = superio_inb(sio_data, WINB_ACT_REG);
        if (!(val & 0x01)) {
                printk(KERN_WARNING DRVNAME ": Enabling HWM logical device\n");
-                superio_outb(WINB_ACT_REG, val | 0x01);
+                superio_outb(sio_data, WINB_ACT_REG, val | 0x01);
        }
        err = 0;
+        sio_data->sioaddr = sioaddr;
        pr_info(DRVNAME ": Found %s chip at %#x\n",
                names[sio_data->type], *addr);
 exit:
-        superio_exit();
+        superio_exit(sio_data);
        return err;
 }
@@ -1511,20 +1497,21 @@ static int w83627hf_read_value(struct w83627hf_data *data, u16 reg)
 static int __devinit w83627thf_read_gpio5(struct platform_device *pdev)
 {
+        struct w83627hf_sio_data *sio_data = pdev->dev.platform_data;
        int res = 0xff, sel;
-        superio_enter();
+        superio_enter(sio_data);
-        superio_select(W83627HF_LD_GPIO5);
+        superio_select(sio_data, W83627HF_LD_GPIO5);
        /* Make sure these GPIO pins are enabled */
-        if (!(superio_inb(W83627THF_GPIO5_EN) & (1<<3))) {
+        if (!(superio_inb(sio_data, W83627THF_GPIO5_EN) & (1<<3))) {
                dev_dbg(&pdev->dev, "GPIO5 disabled, no VID function\n");
                goto exit;
        }
        /* Make sure the pins are configured for input
           There must be at least five (VRM 9), and possibly 6 (VRM 10) */
-        sel = superio_inb(W83627THF_GPIO5_IOSR) & 0x3f;
+        sel = superio_inb(sio_data, W83627THF_GPIO5_IOSR) & 0x3f;
        if ((sel & 0x1f) != 0x1f) {
                dev_dbg(&pdev->dev, "GPIO5 not configured for VID "
                        "function\n");
@@ -1532,37 +1519,38 @@ static int __devinit w83627thf_read_gpio5(struct platform_device *pdev)
        }
        dev_info(&pdev->dev, "Reading VID from GPIO5\n");
-        res = superio_inb(W83627THF_GPIO5_DR) & sel;
+        res = superio_inb(sio_data, W83627THF_GPIO5_DR) & sel;
 exit:
-        superio_exit();
+        superio_exit(sio_data);
        return res;
 }
 static int __devinit w83687thf_read_vid(struct platform_device *pdev)
 {
+        struct w83627hf_sio_data *sio_data = pdev->dev.platform_data;
        int res = 0xff;
-        superio_enter();
+        superio_enter(sio_data);
-        superio_select(W83627HF_LD_HWM);
+        superio_select(sio_data, W83627HF_LD_HWM);
        /* Make sure these GPIO pins are enabled */
-        if (!(superio_inb(W83687THF_VID_EN) & (1 << 2))) {
+        if (!(superio_inb(sio_data, W83687THF_VID_EN) & (1 << 2))) {
                dev_dbg(&pdev->dev, "VID disabled, no VID function\n");
                goto exit;
        }
        /* Make sure the pins are configured for input */
-        if (!(superio_inb(W83687THF_VID_CFG) & (1 << 4))) {
+        if (!(superio_inb(sio_data, W83687THF_VID_CFG) & (1 << 4))) {
                dev_dbg(&pdev->dev, "VID configured as output, "
                        "no VID function\n");
                goto exit;
        }
-        res = superio_inb(W83687THF_VID_DATA) & 0x3f;
+        res = superio_inb(sio_data, W83687THF_VID_DATA) & 0x3f;
 exit:
-        superio_exit();
+        superio_exit(sio_data);
        return res;
 }
diff --git a/drivers/hwmon/w83781d.c b/drivers/hwmon/w83781d.c
index d27ed1bac002..7ab7967da0a0 100644
--- a/drivers/hwmon/w83781d.c
+++ b/drivers/hwmon/w83781d.c
@@ -1054,11 +1054,11 @@ static int
 w83781d_detect(struct i2c_client *client, int kind,
               struct i2c_board_info *info)
 {
-        int val1 = 0, val2;
+        int val1, val2;
        struct w83781d_data *isa = w83781d_data_if_isa();
        struct i2c_adapter *adapter = client->adapter;
        int address = client->addr;
-        const char *client_name = "";
+        const char *client_name;
        enum vendor { winbond, asus } vendid;
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
@@ -1070,98 +1070,73 @@ w83781d_detect(struct i2c_client *client, int kind,
        if (isa)
                mutex_lock(&isa->update_lock);
-        /* The w8378?d may be stuck in some other bank than bank 0. This may
+        if (i2c_smbus_read_byte_data(client, W83781D_REG_CONFIG) & 0x80) {
-           make reading other information impossible. Specify a force=... or
+                dev_dbg(&adapter->dev,
-           force_*=... parameter, and the Winbond will be reset to the right
+                        "Detection of w83781d chip failed at step 3\n");
-           bank. */
+                goto err_nodev;
-        if (kind < 0) {
+        }
-                if (i2c_smbus_read_byte_data
-                    (client, W83781D_REG_CONFIG) & 0x80) {
+        val1 = i2c_smbus_read_byte_data(client, W83781D_REG_BANK);
-                        dev_dbg(&adapter->dev, "Detection of w83781d chip "
+        val2 = i2c_smbus_read_byte_data(client, W83781D_REG_CHIPMAN);
-                                "failed at step 3\n");
+        /* Check for Winbond or Asus ID if in bank 0 */
-                        goto err_nodev;
+        if (!(val1 & 0x07) &&
-                }
+            ((!(val1 & 0x80) && val2 != 0xa3 && val2 != 0xc3) ||
-                val1 = i2c_smbus_read_byte_data(client, W83781D_REG_BANK);
+             ( (val1 & 0x80) && val2 != 0x5c && val2 != 0x12))) {
-                val2 = i2c_smbus_read_byte_data(client, W83781D_REG_CHIPMAN);
+                dev_dbg(&adapter->dev,
-                /* Check for Winbond or Asus ID if in bank 0 */
+                        "Detection of w83781d chip failed at step 4\n");
-                if ((!(val1 & 0x07)) &&
+                goto err_nodev;
-                    (((!(val1 & 0x80)) && (val2 != 0xa3) && (val2 != 0xc3))
+        }
-                     || ((val1 & 0x80) && (val2 != 0x5c) && (val2 != 0x12)))) {
+        /* If Winbond SMBus, check address at 0x48.
-                        dev_dbg(&adapter->dev, "Detection of w83781d chip "
+           Asus doesn't support, except for as99127f rev.2 */
-                                "failed at step 4\n");
+        if ((!(val1 & 0x80) && val2 == 0xa3) ||
+            ( (val1 & 0x80) && val2 == 0x5c)) {
+                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");
                        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 (i2c_smbus_read_byte_data
-                            (client, W83781D_REG_I2C_ADDR) != address) {
-                                dev_dbg(&adapter->dev, "Detection of w83781d "
-                                        "chip failed at step 5\n");
-                                goto err_nodev;
-                        }
-                }
        }
-        /* We have either had a force parameter, or we have already detected the
+        /* Put it now into bank 0 and Vendor ID High Byte */
-           Winbond. Put it now into bank 0 and Vendor ID High Byte */
        i2c_smbus_write_byte_data(client, W83781D_REG_BANK,
                (i2c_smbus_read_byte_data(client, W83781D_REG_BANK)
                 & 0x78) | 0x80);
-        /* Determine the chip type. */
+        /* Get the vendor ID */
-        if (kind <= 0) {
+        val2 = i2c_smbus_read_byte_data(client, W83781D_REG_CHIPMAN);
-                /* get vendor ID */
+        if (val2 == 0x5c)
-                val2 = i2c_smbus_read_byte_data(client, W83781D_REG_CHIPMAN);
+                vendid = winbond;
-                if (val2 == 0x5c)
+        else if (val2 == 0x12)
-                        vendid = winbond;
+                vendid = asus;
-                else if (val2 == 0x12)
+        else {
-                        vendid = asus;
+                dev_dbg(&adapter->dev,
-                else {
+                        "w83781d chip vendor is neither Winbond nor Asus\n");
-                        dev_dbg(&adapter->dev, "w83781d chip vendor is "
+                goto err_nodev;
-                                "neither Winbond nor Asus\n");
-                        goto err_nodev;
-                }
-                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)
-                        kind = w83782d;
-                else if (val1 == 0x40 && vendid == winbond && address == 0x2d)
-                        kind = w83783s;
-                else if (val1 == 0x31)
-                        kind = as99127f;
-                else {
-                        if (kind == 0)
-                                dev_warn(&adapter->dev, "Ignoring 'force' "
-                                         "parameter for unknown chip at "
-                                         "address 0x%02x\n", address);
-                        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)
+        /* Determine the chip type. */
-                mutex_unlock(&isa->update_lock);
+        val1 = i2c_smbus_read_byte_data(client, W83781D_REG_WCHIPID);
+        if ((val1 == 0x10 || val1 == 0x11) && vendid == winbond)
-        if (kind == w83781d) {
                client_name = "w83781d";
-        } else if (kind == w83782d) {
+        else if (val1 == 0x30 && vendid == winbond)
                client_name = "w83782d";
-        } else if (kind == w83783s) {
+        else if (val1 == 0x40 && vendid == winbond && address == 0x2d)
                client_name = "w83783s";
-        } else if (kind == as99127f) {
+        else if (val1 == 0x31)
                client_name = "as99127f";
+        else
+                goto err_nodev;
+        if (val1 <= 0x30 && 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);
        strlcpy(info->type, client_name, I2C_NAME_SIZE);
        return 0;
diff --git a/drivers/hwmon/w83791d.c b/drivers/hwmon/w83791d.c
index 97851c5ba3a3..0410bf12c521 100644
--- a/drivers/hwmon/w83791d.c
+++ b/drivers/hwmon/w83791d.c
@@ -1270,56 +1270,32 @@ static int w83791d_detect(struct i2c_client *client, int kind,
                return -ENODEV;
        }
-        /* The w83791d may be stuck in some other bank than bank 0. This may
+        if (w83791d_read(client, W83791D_REG_CONFIG) & 0x80)
-           make reading other information impossible. Specify a force=...
+                return -ENODEV;
-           parameter, and the Winbond will be reset to the right bank. */
-        if (kind < 0) {
+        val1 = w83791d_read(client, W83791D_REG_BANK);
-                if (w83791d_read(client, W83791D_REG_CONFIG) & 0x80) {
+        val2 = w83791d_read(client, W83791D_REG_CHIPMAN);
-                        return -ENODEV;
+        /* Check for Winbond ID if in bank 0 */
-                }
+        if (!(val1 & 0x07)) {
-                val1 = w83791d_read(client, W83791D_REG_BANK);
+                if ((!(val1 & 0x80) && val2 != 0xa3) ||
-                val2 = w83791d_read(client, W83791D_REG_CHIPMAN);
+                    ( (val1 & 0x80) && val2 != 0x5c)) {
-                /* Check for Winbond ID if in bank 0 */
-                if (!(val1 & 0x07)) {
-                        /* yes it is Bank0 */
-                        if (((!(val1 & 0x80)) && (val2 != 0xa3)) ||
-                            ((val1 & 0x80) && (val2 != 0x5c))) {
-                                return -ENODEV;
-                        }
-                }
-                /* If Winbond chip, address of chip and W83791D_REG_I2C_ADDR
-                   should match */
-                if (w83791d_read(client, W83791D_REG_I2C_ADDR) != address) {
                        return -ENODEV;
                }
        }
+        /* If Winbond chip, address of chip and W83791D_REG_I2C_ADDR
+           should match */
+        if (w83791d_read(client, W83791D_REG_I2C_ADDR) != address)
+                return -ENODEV;
-        /* We either have a force parameter or we have reason to
+        /* We want bank 0 and Vendor ID high byte */
-           believe it is a Winbond chip. Either way, we want bank 0 and
-           Vendor ID high byte */
        val1 = w83791d_read(client, W83791D_REG_BANK) & 0x78;
        w83791d_write(client, W83791D_REG_BANK, val1 | 0x80);
        /* Verify it is a Winbond w83791d */
-        if (kind <= 0) {
+        val1 = w83791d_read(client, W83791D_REG_WCHIPID);
-                /* get vendor ID */
+        val2 = w83791d_read(client, W83791D_REG_CHIPMAN);
-                val2 = w83791d_read(client, W83791D_REG_CHIPMAN);
+        if (val1 != 0x71 || val2 != 0x5c)
-                if (val2 != 0x5c) {     /* the vendor is NOT Winbond */
+                return -ENODEV;
-                        return -ENODEV;
-                }
-                val1 = w83791d_read(client, W83791D_REG_WCHIPID);
-                if (val1 == 0x71) {
-                        kind = w83791d;
-                } else {
-                        if (kind == 0)
-                                dev_warn(&adapter->dev,
-                                        "w83791d: Ignoring 'force' parameter "
-                                        "for unknown chip at adapter %d, "
-                                        "address 0x%02x\n",
-                                        i2c_adapter_id(adapter), address);
-                        return -ENODEV;
-                }
-        }
        strlcpy(info->type, "w83791d", I2C_NAME_SIZE);
diff --git a/drivers/hwmon/w83792d.c b/drivers/hwmon/w83792d.c
index 2be16194ddf3..38978851333f 100644
--- a/drivers/hwmon/w83792d.c
+++ b/drivers/hwmon/w83792d.c
@@ -1273,58 +1273,33 @@ w83792d_detect(struct i2c_client *client, int kind, struct i2c_board_info *info)
                return -ENODEV;
        }
-        /* The w83792d may be stuck in some other bank than bank 0. This may
+        if (w83792d_read_value(client, W83792D_REG_CONFIG) & 0x80)
-           make reading other information impossible. Specify a force=... or
+                return -ENODEV;
-           force_*=... parameter, and the Winbond will be reset to the right
-           bank. */
+        val1 = w83792d_read_value(client, W83792D_REG_BANK);
-        if (kind < 0) {
+        val2 = w83792d_read_value(client, W83792D_REG_CHIPMAN);
-                if (w83792d_read_value(client, W83792D_REG_CONFIG) & 0x80) {
+        /* Check for Winbond ID if in bank 0 */
-                        return -ENODEV;
+        if (!(val1 & 0x07)) {  /* is Bank0 */
-                }
+                if ((!(val1 & 0x80) && val2 != 0xa3) ||
-                val1 = w83792d_read_value(client, W83792D_REG_BANK);
+                    ( (val1 & 0x80) && val2 != 0x5c))
-                val2 = w83792d_read_value(client, W83792D_REG_CHIPMAN);
-                /* Check for Winbond ID if in bank 0 */
-                if (!(val1 & 0x07)) {  /* is Bank0 */
-                        if (((!(val1 & 0x80)) && (val2 != 0xa3)) ||
-                             ((val1 & 0x80) && (val2 != 0x5c))) {
-                                return -ENODEV;
-                        }
-                }
-                /* If Winbond chip, address of chip and W83792D_REG_I2C_ADDR
-                   should match */
-                if (w83792d_read_value(client,
-                                        W83792D_REG_I2C_ADDR) != address) {
                        return -ENODEV;
-                }
        }
+        /* If Winbond chip, address of chip and W83792D_REG_I2C_ADDR
+           should match */
+        if (w83792d_read_value(client, W83792D_REG_I2C_ADDR) != address)
+                return -ENODEV;
-        /* We have either had a force parameter, or we have already detected the
+        /*  Put it now into bank 0 and Vendor ID High Byte */
-           Winbond. Put it now into bank 0 and Vendor ID High Byte */
        w83792d_write_value(client,
                            W83792D_REG_BANK,
                            (w83792d_read_value(client,
                                W83792D_REG_BANK) & 0x78) | 0x80);
        /* Determine the chip type. */
-        if (kind <= 0) {
+        val1 = w83792d_read_value(client, W83792D_REG_WCHIPID);
-                /* get vendor ID */
+        val2 = w83792d_read_value(client, W83792D_REG_CHIPMAN);
-                val2 = w83792d_read_value(client, W83792D_REG_CHIPMAN);
+        if (val1 != 0x7a || val2 != 0x5c)
-                if (val2 != 0x5c) {  /* the vendor is NOT Winbond */
+                return -ENODEV;
-                        return -ENODEV;
-                }
-                val1 = w83792d_read_value(client, W83792D_REG_WCHIPID);
-                if (val1 == 0x7a) {
-                        kind = w83792d;
-                } else {
-                        if (kind == 0)
-                                dev_warn(&adapter->dev,
-                                        "w83792d: Ignoring 'force' parameter for"
-                                        " unknown chip at adapter %d, address"
-                                        " 0x%02x\n", i2c_adapter_id(adapter),
-                                        address);
-                        return -ENODEV;
-                }
-        }
        strlcpy(info->type, "w83792d", I2C_NAME_SIZE);
diff --git a/drivers/hwmon/w83793.c b/drivers/hwmon/w83793.c
index 47dd398f7258..80a2191bf127 100644
--- a/drivers/hwmon/w83793.c
+++ b/drivers/hwmon/w83793.c
@@ -1164,7 +1164,7 @@ ERROR_SC_0:
 static int w83793_detect(struct i2c_client *client, int kind,
                         struct i2c_board_info *info)
 {
-        u8 tmp, bank;
+        u8 tmp, bank, chip_id;
        struct i2c_adapter *adapter = client->adapter;
        unsigned short address = client->addr;
@@ -1174,44 +1174,27 @@ static int w83793_detect(struct i2c_client *client, int kind,
        bank = i2c_smbus_read_byte_data(client, W83793_REG_BANKSEL);
-        if (kind < 0) {
+        tmp = bank & 0x80 ? 0x5c : 0xa3;
-                tmp = bank & 0x80 ? 0x5c : 0xa3;
+        /* Check Winbond vendor ID */
-                /* Check Winbond vendor ID */
+        if (tmp != i2c_smbus_read_byte_data(client, W83793_REG_VENDORID)) {
-                if (tmp != i2c_smbus_read_byte_data(client,
+                pr_debug("w83793: Detection failed at check vendor id\n");
-                                                        W83793_REG_VENDORID)) {
+                return -ENODEV;
-                        pr_debug("w83793: Detection failed at check "
-                                 "vendor id\n");
-                        return -ENODEV;
-                }
-                /* If Winbond chip, address of chip and W83793_REG_I2C_ADDR
-                   should match */
-                if ((bank & 0x07) == 0
-                 && i2c_smbus_read_byte_data(client, W83793_REG_I2C_ADDR) !=
-                    (address << 1)) {
-                        pr_debug("w83793: Detection failed at check "
-                                 "i2c addr\n");
-                        return -ENODEV;
-                }
        }
-        /* We have either had a force parameter, or we have already detected the
+        /* If Winbond chip, address of chip and W83793_REG_I2C_ADDR
-           Winbond. Determine the chip type now */
+           should match */
+        if ((bank & 0x07) == 0
-        if (kind <= 0) {
+         && i2c_smbus_read_byte_data(client, W83793_REG_I2C_ADDR) !=
-                if (0x7b == i2c_smbus_read_byte_data(client,
+            (address << 1)) {
-                                                     W83793_REG_CHIPID)) {
+                pr_debug("w83793: Detection failed at check i2c addr\n");
-                        kind = w83793;
+                return -ENODEV;
-                } else {
-                        if (kind == 0)
-                                dev_warn(&adapter->dev, "w83793: Ignoring "
-                                         "'force' parameter for unknown chip "
-                                         "at address 0x%02x\n", address);
-                        return -ENODEV;
-                }
        }
+        /* Determine the chip type now */
+        chip_id = i2c_smbus_read_byte_data(client, W83793_REG_CHIPID);
+        if (chip_id != 0x7b)
+                return -ENODEV;
        strlcpy(info->type, "w83793", I2C_NAME_SIZE);
        return 0;
diff --git a/drivers/hwmon/w83l785ts.c b/drivers/hwmon/w83l785ts.c
index ea295b9fc4f4..9b6c4c10fba7 100644
--- a/drivers/hwmon/w83l785ts.c
+++ b/drivers/hwmon/w83l785ts.c
@@ -1,7 +1,7 @@
 /*
 * w83l785ts.c - Part of lm_sensors, Linux kernel modules for hardware
 *               monitoring
- * Copyright (C) 2003-2004  Jean Delvare <khali@linux-fr.org>
+ * Copyright (C) 2003-2009  Jean Delvare <khali@linux-fr.org>
 *
 * Inspired from the lm83 driver. The W83L785TS-S is a sensor chip made
 * by Winbond. It reports a single external temperature with a 1 deg
@@ -146,60 +146,36 @@ static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO, show_temp, NULL, 1);
 */
 /* Return 0 if detection is successful, -ENODEV otherwise */
-static int w83l785ts_detect(struct i2c_client *new_client, int kind,
+static int w83l785ts_detect(struct i2c_client *client, int kind,
                            struct i2c_board_info *info)
 {
-        struct i2c_adapter *adapter = new_client->adapter;
+        struct i2c_adapter *adapter = client->adapter;
+        u16 man_id;
+        u8 chip_id;
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                return -ENODEV;
-        /*
+        /* detection */
-         * Now we do the remaining detection. A negative kind means that
+        if ((w83l785ts_read_value(client, W83L785TS_REG_CONFIG, 0) & 0x80)
-         * the driver was loaded with no force parameter (default), so we
+         || (w83l785ts_read_value(client, W83L785TS_REG_TYPE, 0) & 0xFC)) {
-         * must both detect and identify the chip (actually there is only
+                dev_dbg(&adapter->dev,
-         * one possible kind of chip for now, W83L785TS-S). A zero kind means
+                        "W83L785TS-S detection failed at 0x%02x\n",
-         * that the driver was loaded with the force parameter, the detection
+                        client->addr);
-         * step shall be skipped. A positive kind means that the driver
+                return -ENODEV;
-         * was loaded with the force parameter and a given kind of chip is
-         * requested, so both the detection and the identification steps
-         * are skipped.
-         */
-        if (kind < 0) { /* detection */
-                if (((w83l785ts_read_value(new_client,
-                      W83L785TS_REG_CONFIG, 0) & 0x80) != 0x00)
-                 || ((w83l785ts_read_value(new_client,
-                      W83L785TS_REG_TYPE, 0) & 0xFC) != 0x00)) {
-                        dev_dbg(&adapter->dev,
-                                "W83L785TS-S detection failed at 0x%02x.\n",
-                                new_client->addr);
-                        return -ENODEV;
-                }
        }
-        if (kind <= 0) { /* identification */
+        /* Identification */
-                u16 man_id;
+        man_id = (w83l785ts_read_value(client, W83L785TS_REG_MAN_ID1, 0) << 8)
-                u8 chip_id;
+               + w83l785ts_read_value(client, W83L785TS_REG_MAN_ID2, 0);
+        chip_id = w83l785ts_read_value(client, W83L785TS_REG_CHIP_ID, 0);
-                man_id = (w83l785ts_read_value(new_client,
-                         W83L785TS_REG_MAN_ID1, 0) << 8) +
+        if (man_id != 0x5CA3            /* Winbond */
-                         w83l785ts_read_value(new_client,
+         || chip_id != 0x70) {          /* W83L785TS-S */
-                         W83L785TS_REG_MAN_ID2, 0);
+                dev_dbg(&adapter->dev,
-                chip_id = w83l785ts_read_value(new_client,
+                        "Unsupported chip (man_id=0x%04X, chip_id=0x%02X)\n",
-                          W83L785TS_REG_CHIP_ID, 0);
+                        man_id, chip_id);
+                return -ENODEV;
-                if (man_id == 0x5CA3) { /* Winbond */
-                        if (chip_id == 0x70) { /* W83L785TS-S */
-                                kind = w83l785ts;                       
-                        }
-                }
-        
-                if (kind <= 0) { /* identification failed */
-                        dev_info(&adapter->dev,
-                                 "Unsupported chip (man_id=0x%04X, "
-                                 "chip_id=0x%02X).\n", man_id, chip_id);
-                        return -ENODEV;
-                }
        }
        strlcpy(info->type, "w83l785ts", I2C_NAME_SIZE);
diff --git a/drivers/hwmon/w83l786ng.c b/drivers/hwmon/w83l786ng.c
index badca769f350..27da7d2b15fb 100644
--- a/drivers/hwmon/w83l786ng.c
+++ b/drivers/hwmon/w83l786ng.c
@@ -590,53 +590,31 @@ w83l786ng_detect(struct i2c_client *client, int kind,
                 struct i2c_board_info *info)
 {
        struct i2c_adapter *adapter = client->adapter;
+        u16 man_id;
+        u8 chip_id;
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
                return -ENODEV;
        }
-        /*
+        /* Detection */
-         * Now we do the remaining detection. A negative kind means that
+        if ((w83l786ng_read_value(client, W83L786NG_REG_CONFIG) & 0x80)) {
-         * the driver was loaded with no force parameter (default), so we
+                dev_dbg(&adapter->dev, "W83L786NG detection failed at 0x%02x\n",
-         * must both detect and identify the chip (actually there is only
+                        client->addr);
-         * one possible kind of chip for now, W83L786NG). A zero kind means
+                return -ENODEV;
-         * that the driver was loaded with the force parameter, the detection
-         * step shall be skipped. A positive kind means that the driver
-         * was loaded with the force parameter and a given kind of chip is
-         * requested, so both the detection and the identification steps
-         * are skipped.
-         */
-        if (kind < 0) { /* detection */
-                if (((w83l786ng_read_value(client,
-                    W83L786NG_REG_CONFIG) & 0x80) != 0x00)) {
-                        dev_dbg(&adapter->dev,
-                                "W83L786NG detection failed at 0x%02x.\n",
-                                client->addr);
-                        return -ENODEV;
-                }
        }
-        if (kind <= 0) { /* identification */
+        /* Identification */
-                u16 man_id;
+        man_id = (w83l786ng_read_value(client, W83L786NG_REG_MAN_ID1) << 8) +
-                u8 chip_id;
+                 w83l786ng_read_value(client, W83L786NG_REG_MAN_ID2);
+        chip_id = w83l786ng_read_value(client, W83L786NG_REG_CHIP_ID);
-                man_id = (w83l786ng_read_value(client,
-                    W83L786NG_REG_MAN_ID1) << 8) +
-                    w83l786ng_read_value(client, W83L786NG_REG_MAN_ID2);
-                chip_id = w83l786ng_read_value(client, W83L786NG_REG_CHIP_ID);
-                if (man_id == 0x5CA3) { /* Winbond */
-                        if (chip_id == 0x80) { /* W83L786NG */
-                                kind = w83l786ng;
-                        }
-                }
-                if (kind <= 0) { /* identification failed */
+        if (man_id != 0x5CA3 ||         /* Winbond */
-                        dev_info(&adapter->dev,
+            chip_id != 0x80) {          /* W83L786NG */
-                            "Unsupported chip (man_id=0x%04X, "
+                dev_dbg(&adapter->dev,
-                            "chip_id=0x%02X).\n", man_id, chip_id);
+                        "Unsupported chip (man_id=0x%04X, chip_id=0x%02X)\n",
-                        return -ENODEV;
+                        man_id, chip_id);
-                }
+                return -ENODEV;
        }
        strlcpy(info->type, "w83l786ng", I2C_NAME_SIZE);
author	Linus Torvalds <torvalds@linux-foundation.org>	2009-12-09 22:53:11 -0500
committer	Linus Torvalds <torvalds@linux-foundation.org>	2009-12-09 22:53:11 -0500
commit	f71eaf68406cfee91b6a96bcdf7ce33dc78829c5 (patch)
tree	92a1663ae15d521f25849d28ebb4dfad10567892 /drivers
parent	78f1ae193d1662c22cfebb916e788e1ca896c0fe (diff)
parent	54fe4671aa5853ca88da72d67e969a3d8de6dcf6 (diff)