WARNING - OLD ARCHIVES

This is an archived copy of the Xen.org mailing list, which we have preserved to ensure that existing links to archives are not broken. The live archive, which contains the latest emails, can be found at http://lists.xen.org/
   
 
 
Xen 
 
Home Products Support Community News
 
   
 

xen-devel

[Xen-devel] [PATCH 5 of 10] New/Updated drivers: ITE IT87xx and compatib

To: xen-devel@xxxxxxxxxxxxxxxxxxx
Subject: [Xen-devel] [PATCH 5 of 10] New/Updated drivers: ITE IT87xx and compatibles driver backported from Linux Kernel Ver. 2.6.29.2
From: Daniel Kiper <dkiper@xxxxxxxxxxxx>
Date: Tue, 24 Nov 2009 12:42:02 +0100
Delivery-date: Tue, 24 Nov 2009 03:45:22 -0800
Envelope-to: www-data@xxxxxxxxxxxxxxxxxxx
List-help: <mailto:xen-devel-request@lists.xensource.com?subject=help>
List-id: Xen developer discussion <xen-devel.lists.xensource.com>
List-post: <mailto:xen-devel@lists.xensource.com>
List-subscribe: <http://lists.xensource.com/mailman/listinfo/xen-devel>, <mailto:xen-devel-request@lists.xensource.com?subject=subscribe>
List-unsubscribe: <http://lists.xensource.com/mailman/listinfo/xen-devel>, <mailto:xen-devel-request@lists.xensource.com?subject=unsubscribe>
Sender: xen-devel-bounces@xxxxxxxxxxxxxxxxxxx
User-agent: Mutt/1.3.28i
# HG changeset patch
# User root@xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# Date 1259016087 -3600
# Node ID f3aa7ef6367a96b45d4cc39db688f379903a336d
# Parent  1db1bb63824b25f97d127449faeb3a56f1272c97
ITE IT87xx and compatibles driver backported
from Linux Kernel Ver. 2.6.29.2
Signed-off-by: Daniel Kiper <dkiper@xxxxxxxxxxxx>

diff -r 1db1bb63824b -r f3aa7ef6367a Documentation/hwmon/it87
--- a/Documentation/hwmon/it87  Mon Nov 23 07:32:47 2009 +0000
+++ b/Documentation/hwmon/it87  Mon Nov 23 23:41:27 2009 +0100
@@ -6,19 +6,38 @@ Supported chips:
     Prefix: 'it87'
     Addresses scanned: from Super I/O config space (8 I/O ports)
     Datasheet: Publicly available at the ITE website
-               http://www.ite.com.tw/
+               http://www.ite.com.tw/product_info/file/pc/IT8705F_V.0.4.1.pdf
   * IT8712F
     Prefix: 'it8712'
-    Addresses scanned: I2C 0x2d
-                       from Super I/O config space (8 I/O ports)
+    Addresses scanned: from Super I/O config space (8 I/O ports)
     Datasheet: Publicly available at the ITE website
-               http://www.ite.com.tw/
+               http://www.ite.com.tw/product_info/file/pc/IT8712F_V0.9.1.pdf
+               
http://www.ite.com.tw/product_info/file/pc/Errata%20V0.1%20for%20IT8712F%20V0.9.1.pdf
+               http://www.ite.com.tw/product_info/file/pc/IT8712F_V0.9.3.pdf
+  * IT8716F/IT8726F
+    Prefix: 'it8716'
+    Addresses scanned: from Super I/O config space (8 I/O ports)
+    Datasheet: Publicly available at the ITE website
+               http://www.ite.com.tw/product_info/file/pc/IT8716F_V0.3.ZIP
+               http://www.ite.com.tw/product_info/file/pc/IT8726F_V0.3.pdf
+  * IT8718F
+    Prefix: 'it8718'
+    Addresses scanned: from Super I/O config space (8 I/O ports)
+    Datasheet: Publicly available at the ITE website
+               http://www.ite.com.tw/product_info/file/pc/IT8718F_V0.2.zip
+               
http://www.ite.com.tw/product_info/file/pc/IT8718F_V0%203_(for%20C%20version).zip
+  * IT8720F
+    Prefix: 'it8720'
+    Addresses scanned: from Super I/O config space (8 I/O ports)
+    Datasheet: Not yet publicly available.
   * SiS950   [clone of IT8705F]
     Prefix: 'it87'
     Addresses scanned: from Super I/O config space (8 I/O ports)
     Datasheet: No longer be available
 
-Author: Christophe Gauthron <chrisg@xxxxxxxx>
+Authors:
+    Christophe Gauthron
+    Jean Delvare <khali@xxxxxxxxxxxx>
 
 
 Module Parameters
@@ -40,29 +59,65 @@ Module Parameters
   misconfigured by BIOS - PWM values would be inverted. This option tries
   to fix this. Please contact your BIOS manufacturer and ask him for fix.
 
+
+Hardware Interfaces
+-------------------
+
+All the chips suported by this driver are LPC Super-I/O chips, accessed
+through the LPC bus (ISA-like I/O ports). The IT8712F additionally has an
+SMBus interface to the hardware monitoring functions. This driver no
+longer supports this interface though, as it is slower and less reliable
+than the ISA access, and was only available on a small number of
+motherboard models.
+
+
 Description
 -----------
 
-This driver implements support for the IT8705F, IT8712F and SiS950 chips.
-
-This driver also supports IT8712F, which adds SMBus access, and a VID
-input, used to report the Vcore voltage of the Pentium processor.
-The IT8712F additionally features VID inputs.
+This driver implements support for the IT8705F, IT8712F, IT8716F,
+IT8718F, IT8720F, IT8726F and SiS950 chips.
 
 These chips are 'Super I/O chips', supporting floppy disks, infrared ports,
 joysticks and other miscellaneous stuff. For hardware monitoring, they
 include an 'environment controller' with 3 temperature sensors, 3 fan
 rotation speed sensors, 8 voltage sensors, and associated alarms.
 
+The IT8712F and IT8716F additionally feature VID inputs, used to report
+the Vcore voltage of the processor. The early IT8712F have 5 VID pins,
+the IT8716F and late IT8712F have 6. They are shared with other functions
+though, so the functionality may not be available on a given system.
+The driver dumbly assume it is there.
+
+The IT8718F and IT8720F also features VID inputs (up to 8 pins) but the value
+is stored in the Super-I/O configuration space. Due to technical limitations,
+this value can currently only be read once at initialization time, so
+the driver won't notice and report changes in the VID value. The two
+upper VID bits share their pins with voltage inputs (in5 and in6) so you
+can't have both on a given board.
+
+The IT8716F, IT8718F, IT8720F and later IT8712F revisions have support for
+2 additional fans. The additional fans are supported by the driver.
+
+The IT8716F, IT8718F and IT8720F, and late IT8712F and IT8705F also have
+optional 16-bit tachometer counters for fans 1 to 3. This is better (no more
+fan clock divider mess) but not compatible with the older chips and
+revisions. The 16-bit tachometer mode is enabled by the driver when one
+of the above chips is detected.
+
+The IT8726F is just bit enhanced IT8716F with additional hardware
+for AMD power sequencing. Therefore the chip will appear as IT8716F
+to userspace applications.
+
 Temperatures are measured in degrees Celsius. An alarm is triggered once
 when the Overtemperature Shutdown limit is crossed.
 
 Fan rotation speeds are reported in RPM (rotations per minute). An alarm is
-triggered if the rotation speed has dropped below a programmable limit. Fan
-readings can be divided by a programmable divider (1, 2, 4 or 8) to give the
-readings more range or accuracy. Not all RPM values can accurately be
-represented, so some rounding is done. With a divider of 2, the lowest
-representable value is around 2600 RPM.
+triggered if the rotation speed has dropped below a programmable limit. When
+16-bit tachometer counters aren't used, fan readings can be divided by
+a programmable divider (1, 2, 4 or 8) to give the readings more range or
+accuracy. With a divider of 2, the lowest representable value is around
+2600 RPM. Not all RPM values can accurately be represented, so some rounding
+is done.
 
 Voltage sensors (also known as IN sensors) report their values in volts. An
 alarm is triggered if the voltage has crossed a programmable minimum or
@@ -71,9 +126,9 @@ inputs can measure voltages between 0 an
 inputs can measure voltages between 0 and 4.08 volts, with a resolution of
 0.016 volt. The battery voltage in8 does not have limit registers.
 
-The VID lines (IT8712F only) encode the core voltage value: the voltage
-level your processor should work with. This is hardcoded by the mainboard
-and/or processor itself. It is a value in volts.
+The VID lines (IT8712F/IT8716F/IT8718F/IT8720F) encode the core voltage value:
+the voltage level your processor should work with. This is hardcoded by
+the mainboard and/or processor itself. It is a value in volts.
 
 If an alarm triggers, it will remain triggered until the hardware register
 is read at least once. This means that the cause for the alarm may already
@@ -85,12 +140,22 @@ The IT87xx only updates its values each 
 The IT87xx only updates its values each 1.5 seconds; reading it more often
 will do no harm, but will return 'old' values.
 
-To change sensor N to a thermistor, 'echo 2 > tempN_type' where N is 1, 2,
+To change sensor N to a thermistor, 'echo 4 > tempN_type' where N is 1, 2,
 or 3. To change sensor N to a thermal diode, 'echo 3 > tempN_type'.
 Give 0 for unused sensor. Any other value is invalid. To configure this at
-startup, consult lm_sensors's /etc/sensors.conf. (2 = thermistor;
+startup, consult lm_sensors's /etc/sensors.conf. (4 = thermistor;
 3 = thermal diode)
+
+
+Fan speed control
+-----------------
 
 The fan speed control features are limited to manual PWM mode. Automatic
 "Smart Guardian" mode control handling is not implemented. However
 if you want to go for "manual mode" just write 1 to pwmN_enable.
+
+If you are only able to control the fan speed with very small PWM values,
+try lowering the PWM base frequency (pwm1_freq). Depending on the fan,
+it may give you a somewhat greater control range. The same frequency is
+used to drive all fan outputs, which is why pwm2_freq and pwm3_freq are
+read-only.
diff -r 1db1bb63824b -r f3aa7ef6367a drivers/hwmon/Kconfig
--- a/drivers/hwmon/Kconfig     Mon Nov 23 07:32:47 2009 +0000
+++ b/drivers/hwmon/Kconfig     Mon Nov 23 23:41:27 2009 +0100
@@ -183,11 +183,11 @@ config SENSORS_IT87
 config SENSORS_IT87
        tristate "ITE IT87xx and compatibles"
        depends on HWMON && I2C
-       select I2C_ISA
-       select HWMON_VID
-       help
-         If you say yes here you get support for ITE IT87xx sensor chips
-         and clones: SiS960.
+       select HWMON_VID
+       help
+         If you say yes here you get support for ITE IT8705F, IT8712F,
+         IT8716F, IT8718F, IT8720F and IT8726F sensor chips, and the
+         SiS960 clone.
 
          This driver can also be built as a module.  If so, the module
          will be called it87.
diff -r 1db1bb63824b -r f3aa7ef6367a drivers/hwmon/it87.c
--- a/drivers/hwmon/it87.c      Mon Nov 23 07:32:47 2009 +0000
+++ b/drivers/hwmon/it87.c      Mon Nov 23 23:41:27 2009 +0100
@@ -2,12 +2,24 @@
     it87.c - Part of lm_sensors, Linux kernel modules for hardware
              monitoring.
 
+    The IT8705F is an LPC-based Super I/O part that contains UARTs, a
+    parallel port, an IR port, a MIDI port, a floppy controller, etc., in
+    addition to an Environment Controller (Enhanced Hardware Monitor and
+    Fan Controller)
+
+    This driver supports only the Environment Controller in the IT8705F and
+    similar parts.  The other devices are supported by different drivers.
+
     Supports: IT8705F  Super I/O chip w/LPC interface
-              IT8712F  Super I/O chip w/LPC interface & SMBus
+              IT8712F  Super I/O chip w/LPC interface
+              IT8716F  Super I/O chip w/LPC interface
+              IT8718F  Super I/O chip w/LPC interface
+              IT8720F  Super I/O chip w/LPC interface
+              IT8726F  Super I/O chip w/LPC interface
               Sis950   A clone of the IT8705F
 
-    Copyright (C) 2001 Chris Gauthron <chrisg@xxxxxxxx> 
-    Largely inspired by lm78.c of the same package
+    Copyright (C) 2001 Chris Gauthron
+    Copyright (C) 2005-2007 Jean Delvare <khali@xxxxxxxxxxxx>
 
     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
@@ -24,38 +36,40 @@
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
-/*
-    djg@xxxxxxxx David Gesswein 7/18/01
-    Modified to fix bug with not all alarms enabled.
-    Added ability to read battery voltage and select temperature sensor
-    type at module load time.
-*/
-
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/jiffies.h>
-#include <linux/i2c.h>
-#include <linux/i2c-isa.h>
+#include <linux/platform_device.h>
 #include <linux/hwmon.h>
 #include <linux/hwmon-sysfs.h>
 #include <linux/hwmon-vid.h>
 #include <linux/err.h>
 #include <linux/mutex.h>
+#include <linux/sysfs.h>
+#include <linux/string.h>
+#include <linux/dmi.h>
+#include <linux/acpi.h>
 #include <asm/io.h>
 
-
-/* Addresses to scan */
-static unsigned short normal_i2c[] = { 0x2d, I2C_CLIENT_END };
-static unsigned short isa_address;
-
-/* Insmod parameters */
-I2C_CLIENT_INSMOD_2(it87, it8712);
+#define DRVNAME "it87"
+
+enum chips { it87, it8712, it8716, it8718, it8720 };
+
+static unsigned short force_id;
+module_param(force_id, ushort, 0);
+MODULE_PARM_DESC(force_id, "Override the detected device ID");
+
+static struct platform_device *pdev;
 
 #define        REG     0x2e    /* The register to read/write */
 #define        DEV     0x07    /* Register: Logical device select */
 #define        VAL     0x2f    /* The value to read/write */
 #define PME    0x04    /* The device with the fan registers in it */
+
+/* The device with the IT8718F/IT8720F VID value in it */
+#define GPIO   0x07
+
 #define        DEVID   0x20    /* Register: Device ID */
 #define        DEVREV  0x22    /* Register: Device Revision */
 
@@ -77,10 +91,10 @@ static int superio_inw(int reg)
 }
 
 static inline void
-superio_select(void)
+superio_select(int ldn)
 {
        outb(DEV, REG);
-       outb(PME, VAL);
+       outb(ldn, VAL);
 }
 
 static inline void
@@ -99,29 +113,40 @@ superio_exit(void)
        outb(0x02, VAL);
 }
 
+/* Logical device 4 registers */
 #define IT8712F_DEVID 0x8712
 #define IT8705F_DEVID 0x8705
+#define IT8716F_DEVID 0x8716
+#define IT8718F_DEVID 0x8718
+#define IT8720F_DEVID 0x8720
+#define IT8726F_DEVID 0x8726
 #define IT87_ACT_REG  0x30
 #define IT87_BASE_REG 0x60
 
+/* Logical device 7 registers (IT8712F and later) */
+#define IT87_SIO_PINX2_REG     0x2c    /* Pin selection */
+#define IT87_SIO_VID_REG       0xfc    /* VID value */
+
 /* Update battery voltage after every reading if true */
 static int update_vbat;
 
 /* Not all BIOSes properly configure the PWM registers */
 static int fix_pwm_polarity;
 
-/* Chip Type */
-
-static u16 chip_type;
-
 /* Many IT87 constants specified below */
 
 /* Length of ISA address segment */
 #define IT87_EXTENT 8
 
-/* Where are the ISA address/data registers relative to the base address */
-#define IT87_ADDR_REG_OFFSET 5
-#define IT87_DATA_REG_OFFSET 6
+/* Length of ISA address segment for Environmental Controller */
+#define IT87_EC_EXTENT 2
+
+/* Offset of EC registers from ISA base address */
+#define IT87_EC_OFFSET 5
+
+/* Where are the ISA address/data registers relative to the EC base address */
+#define IT87_ADDR_REG_OFFSET 0
+#define IT87_DATA_REG_OFFSET 1
 
 /*----- The IT87 registers -----*/
 
@@ -131,13 +156,21 @@ static u16 chip_type;
 #define IT87_REG_ALARM2        0x02
 #define IT87_REG_ALARM3        0x03
 
+/* The IT8718F and IT8720F have the VID value in a different register, in
+   Super-I/O configuration space. */
 #define IT87_REG_VID           0x0a
+/* The IT8705F and IT8712F earlier than revision 0x08 use register 0x0b
+   for fan divisors. Later IT8712F revisions must use 16-bit tachometer
+   mode. */
 #define IT87_REG_FAN_DIV       0x0b
+#define IT87_REG_FAN_16BIT     0x0c
 
 /* Monitors: 9 voltage (0 to 7, battery), 3 temp (1 to 3), 3 fan (1 to 3) */
 
-#define IT87_REG_FAN(nr)       (0x0d + (nr))
-#define IT87_REG_FAN_MIN(nr)   (0x10 + (nr))
+static const u8 IT87_REG_FAN[]         = { 0x0d, 0x0e, 0x0f, 0x80, 0x82 };
+static const u8 IT87_REG_FAN_MIN[]     = { 0x10, 0x11, 0x12, 0x84, 0x86 };
+static const u8 IT87_REG_FANX[]                = { 0x18, 0x19, 0x1a, 0x81, 
0x83 };
+static const u8 IT87_REG_FANX_MIN[]    = { 0x1b, 0x1c, 0x1d, 0x85, 0x87 };
 #define IT87_REG_FAN_MAIN_CTRL 0x13
 #define IT87_REG_FAN_CTL       0x14
 #define IT87_REG_PWM(nr)       (0x15 + (nr))
@@ -149,8 +182,6 @@ static u16 chip_type;
 #define IT87_REG_VIN_MIN(nr)   (0x31 + (nr) * 2)
 #define IT87_REG_TEMP_HIGH(nr) (0x40 + (nr) * 2)
 #define IT87_REG_TEMP_LOW(nr)  (0x41 + (nr) * 2)
-
-#define IT87_REG_I2C_ADDR      0x48
 
 #define IT87_REG_VIN_ENABLE    0x50
 #define IT87_REG_TEMP_ENABLE   0x51
@@ -169,11 +200,20 @@ static inline u8 FAN_TO_REG(long rpm, in
                             254);
 }
 
+static inline u16 FAN16_TO_REG(long rpm)
+{
+       if (rpm == 0)
+               return 0xffff;
+       return SENSORS_LIMIT((1350000 + rpm) / (rpm * 2), 1, 0xfffe);
+}
+
 #define FAN_FROM_REG(val,div) ((val)==0?-1:(val)==255?0:1350000/((val)*(div)))
+/* The divider is fixed to 2 in 16-bit mode */
+#define FAN16_FROM_REG(val) ((val)==0?-1:(val)==0xffff?0:1350000/((val)*2))
 
 #define TEMP_TO_REG(val) (SENSORS_LIMIT(((val)<0?(((val)-500)/1000):\
                                        ((val)+500)/1000),-128,127))
-#define TEMP_FROM_REG(val) (((val)>0x80?(val)-0x100:(val))*1000)
+#define TEMP_FROM_REG(val) ((val) * 1000)
 
 #define PWM_TO_REG(val)   ((val) >> 1)
 #define PWM_FROM_REG(val) (((val)&0x7f) << 1)
@@ -181,74 +221,95 @@ static int DIV_TO_REG(int val)
 static int DIV_TO_REG(int val)
 {
        int answer = 0;
-       while ((val >>= 1) != 0)
+       while (answer < 7 && (val >>= 1))
                answer++;
        return answer;
 }
 #define DIV_FROM_REG(val) (1 << (val))
 
-
-/* For each registered IT87, we need to keep some data in memory. That
-   data is pointed to by it87_list[NR]->data. The structure itself is
-   dynamically allocated, at the same time when a new it87 client is
-   allocated. */
+static const unsigned int pwm_freq[8] = {
+       48000000 / 128,
+       24000000 / 128,
+       12000000 / 128,
+       8000000 / 128,
+       6000000 / 128,
+       3000000 / 128,
+       1500000 / 128,
+       750000 / 128,
+};
+
+
+struct it87_sio_data {
+       enum chips type;
+       /* Values read from Super-I/O config space */
+       u8 revision;
+       u8 vid_value;
+       /* Values set based on DMI strings */
+       u8 skip_pwm;
+};
+
+/* For each registered chip, we need to keep some data in memory.
+   The structure is dynamically allocated. */
 struct it87_data {
-       struct i2c_client client;
-       struct class_device *class_dev;
-       struct mutex lock;
+       struct class_device *hwmon_dev;
        enum chips type;
-
+       u8 revision;
+
+       unsigned short addr;
+       const char *name;
        struct mutex update_lock;
        char valid;             /* !=0 if following fields are valid */
        unsigned long last_updated;     /* In jiffies */
 
        u8 in[9];               /* Register value */
-       u8 in_max[9];           /* Register value */
-       u8 in_min[9];           /* Register value */
-       u8 fan[3];              /* Register value */
-       u8 fan_min[3];          /* Register value */
-       u8 temp[3];             /* Register value */
-       u8 temp_high[3];        /* Register value */
-       u8 temp_low[3];         /* Register value */
+       u8 in_max[8];           /* Register value */
+       u8 in_min[8];           /* Register value */
+       u8 has_fan;             /* Bitfield, fans enabled */
+       u16 fan[5];             /* Register values, possibly combined */
+       u16 fan_min[5];         /* Register values, possibly combined */
+       s8 temp[3];             /* Register value */
+       s8 temp_high[3];        /* Register value */
+       s8 temp_low[3];         /* Register value */
        u8 sensor;              /* Register value */
        u8 fan_div[3];          /* Register encoding, shifted right */
        u8 vid;                 /* Register encoding, combined */
        u8 vrm;
        u32 alarms;             /* Register encoding, combined */
        u8 fan_main_ctrl;       /* Register value */
+       u8 fan_ctl;             /* Register value */
        u8 manual_pwm_ctl[3];   /* manual PWM value set by user */
 };
 
-
-static int it87_attach_adapter(struct i2c_adapter *adapter);
-static int it87_isa_attach_adapter(struct i2c_adapter *adapter);
-static int it87_detect(struct i2c_adapter *adapter, int address, int kind);
-static int it87_detach_client(struct i2c_client *client);
-
-static int it87_read_value(struct i2c_client *client, u8 reg);
-static int it87_write_value(struct i2c_client *client, u8 reg, u8 value);
+static inline int has_16bit_fans(const struct it87_data *data)
+{
+       /* IT8705F Datasheet 0.4.1, 3h == Version G.
+          IT8712F Datasheet 0.9.1, section 8.3.5 indicates 8h == Version J.
+          These are the first revisions with 16bit tachometer support. */
+       return (data->type == it87 && data->revision >= 0x03)
+           || (data->type == it8712 && data->revision >= 0x08)
+           || data->type == it8716
+           || data->type == it8718
+           || data->type == it8720;
+}
+
+static int it87_probe(struct platform_device *pdev);
+static int __devexit it87_remove(struct platform_device *pdev);
+
+static int it87_read_value(struct it87_data *data, u8 reg);
+static void it87_write_value(struct it87_data *data, u8 reg, u8 value);
 static struct it87_data *it87_update_device(struct device *dev);
-static int it87_check_pwm(struct i2c_client *client);
-static void it87_init_client(struct i2c_client *client, struct it87_data 
*data);
-
-
-static struct i2c_driver it87_driver = {
+static int it87_check_pwm(struct device *dev);
+static void it87_init_device(struct platform_device *pdev);
+
+
+static struct platform_driver it87_driver = {
        .driver = {
-               .name   = "it87",
+               .owner  = THIS_MODULE,
+               .name   = DRVNAME,
        },
-       .id             = I2C_DRIVERID_IT87,
-       .attach_adapter = it87_attach_adapter,
-       .detach_client  = it87_detach_client,
+       .probe  = it87_probe,
+       .remove = __devexit_p(it87_remove),
 };
-
-static struct i2c_driver it87_isa_driver = {
-       .driver = {
-               .name   = "it87-isa",
-       },
-       .attach_adapter = it87_isa_attach_adapter,
-       .detach_client  = it87_detach_client,
-};
-
 
 static ssize_t show_in(struct device *dev, struct device_attribute *attr,
                char *buf)
@@ -286,13 +347,12 @@ static ssize_t set_in_min(struct device 
        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
        int nr = sensor_attr->index;
 
-       struct i2c_client *client = to_i2c_client(dev);
-       struct it87_data *data = i2c_get_clientdata(client);
+       struct it87_data *data = dev_get_drvdata(dev);
        unsigned long val = simple_strtoul(buf, NULL, 10);
 
        mutex_lock(&data->update_lock);
        data->in_min[nr] = IN_TO_REG(val);
-       it87_write_value(client, IT87_REG_VIN_MIN(nr), 
+       it87_write_value(data, IT87_REG_VIN_MIN(nr),
                        data->in_min[nr]);
        mutex_unlock(&data->update_lock);
        return count;
@@ -303,13 +363,12 @@ static ssize_t set_in_max(struct device 
        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
        int nr = sensor_attr->index;
 
-       struct i2c_client *client = to_i2c_client(dev);
-       struct it87_data *data = i2c_get_clientdata(client);
+       struct it87_data *data = dev_get_drvdata(dev);
        unsigned long val = simple_strtoul(buf, NULL, 10);
 
        mutex_lock(&data->update_lock);
        data->in_max[nr] = IN_TO_REG(val);
-       it87_write_value(client, IT87_REG_VIN_MAX(nr), 
+       it87_write_value(data, IT87_REG_VIN_MAX(nr),
                        data->in_max[nr]);
        mutex_unlock(&data->update_lock);
        return count;
@@ -377,13 +436,12 @@ static ssize_t set_temp_max(struct devic
        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
        int nr = sensor_attr->index;
 
-       struct i2c_client *client = to_i2c_client(dev);
-       struct it87_data *data = i2c_get_clientdata(client);
+       struct it87_data *data = dev_get_drvdata(dev);
        int val = simple_strtol(buf, NULL, 10);
 
        mutex_lock(&data->update_lock);
        data->temp_high[nr] = TEMP_TO_REG(val);
-       it87_write_value(client, IT87_REG_TEMP_HIGH(nr), data->temp_high[nr]);
+       it87_write_value(data, IT87_REG_TEMP_HIGH(nr), data->temp_high[nr]);
        mutex_unlock(&data->update_lock);
        return count;
 }
@@ -393,13 +451,12 @@ static ssize_t set_temp_min(struct devic
        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
        int nr = sensor_attr->index;
 
-       struct i2c_client *client = to_i2c_client(dev);
-       struct it87_data *data = i2c_get_clientdata(client);
+       struct it87_data *data = dev_get_drvdata(dev);
        int val = simple_strtol(buf, NULL, 10);
 
        mutex_lock(&data->update_lock);
        data->temp_low[nr] = TEMP_TO_REG(val);
-       it87_write_value(client, IT87_REG_TEMP_LOW(nr), data->temp_low[nr]);
+       it87_write_value(data, IT87_REG_TEMP_LOW(nr), data->temp_low[nr]);
        mutex_unlock(&data->update_lock);
        return count;
 }
@@ -427,7 +484,7 @@ static ssize_t show_sensor(struct device
        if (reg & (1 << nr))
                return sprintf(buf, "3\n");  /* thermal diode */
        if (reg & (8 << nr))
-               return sprintf(buf, "2\n");  /* thermistor */
+               return sprintf(buf, "4\n");  /* thermistor */
        return sprintf(buf, "0\n");      /* disabled */
 }
 static ssize_t set_sensor(struct device *dev, struct device_attribute *attr,
@@ -436,24 +493,28 @@ static ssize_t set_sensor(struct device 
        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
        int nr = sensor_attr->index;
 
-       struct i2c_client *client = to_i2c_client(dev);
-       struct it87_data *data = i2c_get_clientdata(client);
+       struct it87_data *data = dev_get_drvdata(dev);
        int val = simple_strtol(buf, NULL, 10);
 
        mutex_lock(&data->update_lock);
 
        data->sensor &= ~(1 << nr);
        data->sensor &= ~(8 << nr);
-       /* 3 = thermal diode; 2 = thermistor; 0 = disabled */
+       if (val == 2) { /* backwards compatibility */
+               dev_warn(dev, "Sensor type 2 is deprecated, please use 4 "
+                        "instead\n");
+               val = 4;
+       }
+       /* 3 = thermal diode; 4 = thermistor; 0 = disabled */
        if (val == 3)
            data->sensor |= 1 << nr;
-       else if (val == 2)
+       else if (val == 4)
            data->sensor |= 8 << nr;
        else if (val != 0) {
                mutex_unlock(&data->update_lock);
                return -EINVAL;
        }
-       it87_write_value(client, IT87_REG_TEMP_ENABLE, data->sensor);
+       it87_write_value(data, IT87_REG_TEMP_ENABLE, data->sensor);
        mutex_unlock(&data->update_lock);
        return count;
 }
@@ -513,18 +574,26 @@ static ssize_t show_pwm(struct device *d
        struct it87_data *data = it87_update_device(dev);
        return sprintf(buf,"%d\n", data->manual_pwm_ctl[nr]);
 }
+static ssize_t show_pwm_freq(struct device *dev, struct device_attribute *attr,
+               char *buf)
+{
+       struct it87_data *data = it87_update_device(dev);
+       int index = (data->fan_ctl >> 4) & 0x07;
+
+       return sprintf(buf, "%u\n", pwm_freq[index]);
+}
 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
                const char *buf, size_t count)
 {
        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
        int nr = sensor_attr->index;
 
-       struct i2c_client *client = to_i2c_client(dev);
-       struct it87_data *data = i2c_get_clientdata(client);
+       struct it87_data *data = dev_get_drvdata(dev);
        int val = simple_strtol(buf, NULL, 10);
-       u8 reg = it87_read_value(client, IT87_REG_FAN_DIV);
+       u8 reg;
 
        mutex_lock(&data->update_lock);
+       reg = it87_read_value(data, IT87_REG_FAN_DIV);
        switch (nr) {
        case 0: data->fan_div[nr] = reg & 0x07; break;
        case 1: data->fan_div[nr] = (reg >> 3) & 0x07; break;
@@ -532,7 +601,7 @@ static ssize_t set_fan_min(struct device
        }
 
        data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
-       it87_write_value(client, IT87_REG_FAN_MIN(nr), data->fan_min[nr]);
+       it87_write_value(data, IT87_REG_FAN_MIN[nr], data->fan_min[nr]);
        mutex_unlock(&data->update_lock);
        return count;
 }
@@ -542,17 +611,16 @@ static ssize_t set_fan_div(struct device
        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
        int nr = sensor_attr->index;
 
-       struct i2c_client *client = to_i2c_client(dev);
-       struct it87_data *data = i2c_get_clientdata(client);
-       int val = simple_strtol(buf, NULL, 10);
-       int i, min[3];
+       struct it87_data *data = dev_get_drvdata(dev);
+       unsigned long val = simple_strtoul(buf, NULL, 10);
+       int min;
        u8 old;
 
        mutex_lock(&data->update_lock);
-       old = it87_read_value(client, IT87_REG_FAN_DIV);
-
-       for (i = 0; i < 3; i++)
-               min[i] = FAN_FROM_REG(data->fan_min[i], 
DIV_FROM_REG(data->fan_div[i]));
+       old = it87_read_value(data, IT87_REG_FAN_DIV);
+
+       /* Save fan min limit */
+       min = FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr]));
 
        switch (nr) {
        case 0:
@@ -570,12 +638,12 @@ static ssize_t set_fan_div(struct device
        val |= (data->fan_div[1] & 0x07) << 3;
        if (data->fan_div[2] == 3)
                val |= 0x1 << 6;
-       it87_write_value(client, IT87_REG_FAN_DIV, val);
-
-       for (i = 0; i < 3; i++) {
-               data->fan_min[i]=FAN_TO_REG(min[i], 
DIV_FROM_REG(data->fan_div[i]));
-               it87_write_value(client, IT87_REG_FAN_MIN(i), data->fan_min[i]);
-       }
+       it87_write_value(data, IT87_REG_FAN_DIV, val);
+
+       /* Restore fan min limit */
+       data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
+       it87_write_value(data, IT87_REG_FAN_MIN[nr], data->fan_min[nr]);
+
        mutex_unlock(&data->update_lock);
        return count;
 }
@@ -585,8 +653,7 @@ static ssize_t set_pwm_enable(struct dev
        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
        int nr = sensor_attr->index;
 
-       struct i2c_client *client = to_i2c_client(dev);
-       struct it87_data *data = i2c_get_clientdata(client);
+       struct it87_data *data = dev_get_drvdata(dev);
        int val = simple_strtol(buf, NULL, 10);
 
        mutex_lock(&data->update_lock);
@@ -594,17 +661,17 @@ static ssize_t set_pwm_enable(struct dev
        if (val == 0) {
                int tmp;
                /* make sure the fan is on when in on/off mode */
-               tmp = it87_read_value(client, IT87_REG_FAN_CTL);
-               it87_write_value(client, IT87_REG_FAN_CTL, tmp | (1 << nr));
+               tmp = it87_read_value(data, IT87_REG_FAN_CTL);
+               it87_write_value(data, IT87_REG_FAN_CTL, tmp | (1 << nr));
                /* set on/off mode */
                data->fan_main_ctrl &= ~(1 << nr);
-               it87_write_value(client, IT87_REG_FAN_MAIN_CTRL, 
data->fan_main_ctrl);
+               it87_write_value(data, IT87_REG_FAN_MAIN_CTRL, 
data->fan_main_ctrl);
        } else if (val == 1) {
                /* set SmartGuardian mode */
                data->fan_main_ctrl |= (1 << nr);
-               it87_write_value(client, IT87_REG_FAN_MAIN_CTRL, 
data->fan_main_ctrl);
+               it87_write_value(data, IT87_REG_FAN_MAIN_CTRL, 
data->fan_main_ctrl);
                /* set saved pwm value, clear FAN_CTLX PWM mode bit */
-               it87_write_value(client, IT87_REG_PWM(nr), 
PWM_TO_REG(data->manual_pwm_ctl[nr]));
+               it87_write_value(data, IT87_REG_PWM(nr), 
PWM_TO_REG(data->manual_pwm_ctl[nr]));
        } else {
                mutex_unlock(&data->update_lock);
                return -EINVAL;
@@ -619,8 +686,7 @@ static ssize_t set_pwm(struct device *de
        struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
        int nr = sensor_attr->index;
 
-       struct i2c_client *client = to_i2c_client(dev);
-       struct it87_data *data = i2c_get_clientdata(client);
+       struct it87_data *data = dev_get_drvdata(dev);
        int val = simple_strtol(buf, NULL, 10);
 
        if (val < 0 || val > 255)
@@ -629,8 +695,29 @@ static ssize_t set_pwm(struct device *de
        mutex_lock(&data->update_lock);
        data->manual_pwm_ctl[nr] = val;
        if (data->fan_main_ctrl & (1 << nr))
-               it87_write_value(client, IT87_REG_PWM(nr), 
PWM_TO_REG(data->manual_pwm_ctl[nr]));
+               it87_write_value(data, IT87_REG_PWM(nr), 
PWM_TO_REG(data->manual_pwm_ctl[nr]));
        mutex_unlock(&data->update_lock);
+       return count;
+}
+static ssize_t set_pwm_freq(struct device *dev,
+               struct device_attribute *attr, const char *buf, size_t count)
+{
+       struct it87_data *data = dev_get_drvdata(dev);
+       unsigned long val = simple_strtoul(buf, NULL, 10);
+       int i;
+
+       /* Search for the nearest available frequency */
+       for (i = 0; i < 7; i++) {
+               if (val > (pwm_freq[i] + pwm_freq[i+1]) / 2)
+                       break;
+       }
+
+       mutex_lock(&data->update_lock);
+       data->fan_ctl = it87_read_value(data, IT87_REG_FAN_CTL) & 0x8f;
+       data->fan_ctl |= i << 4;
+       it87_write_value(data, IT87_REG_FAN_CTL, data->fan_ctl);
+       mutex_unlock(&data->update_lock);
+
        return count;
 }
 
@@ -650,12 +737,69 @@ static SENSOR_DEVICE_ATTR(pwm##offset##_
 static SENSOR_DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR,     \
                show_pwm_enable, set_pwm_enable, offset - 1);           \
 static SENSOR_DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR,              \
-               show_pwm, set_pwm, offset - 1);
+               show_pwm, set_pwm, offset - 1);                         \
+static DEVICE_ATTR(pwm##offset##_freq,                                 \
+               (offset == 1 ? S_IRUGO | S_IWUSR : S_IRUGO),            \
+               show_pwm_freq, (offset == 1 ? set_pwm_freq : NULL));
 
 show_pwm_offset(1);
 show_pwm_offset(2);
 show_pwm_offset(3);
 
+/* A different set of callbacks for 16-bit fans */
+static ssize_t show_fan16(struct device *dev, struct device_attribute *attr,
+               char *buf)
+{
+       struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
+       int nr = sensor_attr->index;
+       struct it87_data *data = it87_update_device(dev);
+       return sprintf(buf, "%d\n", FAN16_FROM_REG(data->fan[nr]));
+}
+
+static ssize_t show_fan16_min(struct device *dev, struct device_attribute 
*attr,
+               char *buf)
+{
+       struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
+       int nr = sensor_attr->index;
+       struct it87_data *data = it87_update_device(dev);
+       return sprintf(buf, "%d\n", FAN16_FROM_REG(data->fan_min[nr]));
+}
+
+static ssize_t set_fan16_min(struct device *dev, struct device_attribute *attr,
+               const char *buf, size_t count)
+{
+       struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
+       int nr = sensor_attr->index;
+       struct it87_data *data = dev_get_drvdata(dev);
+       int val = simple_strtol(buf, NULL, 10);
+
+       mutex_lock(&data->update_lock);
+       data->fan_min[nr] = FAN16_TO_REG(val);
+       it87_write_value(data, IT87_REG_FAN_MIN[nr],
+                        data->fan_min[nr] & 0xff);
+       it87_write_value(data, IT87_REG_FANX_MIN[nr],
+                        data->fan_min[nr] >> 8);
+       mutex_unlock(&data->update_lock);
+       return count;
+}
+
+/* We want to use the same sysfs file names as 8-bit fans, but we need
+   different variable names, so we have to use SENSOR_ATTR instead of
+   SENSOR_DEVICE_ATTR. */
+#define show_fan16_offset(offset) \
+static struct sensor_device_attribute sensor_dev_attr_fan##offset##_input16 \
+       = SENSOR_ATTR(fan##offset##_input, S_IRUGO,             \
+               show_fan16, NULL, offset - 1);                  \
+static struct sensor_device_attribute sensor_dev_attr_fan##offset##_min16 \
+       = SENSOR_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR,     \
+               show_fan16_min, set_fan16_min, offset - 1)
+
+show_fan16_offset(1);
+show_fan16_offset(2);
+show_fan16_offset(3);
+show_fan16_offset(4);
+show_fan16_offset(5);
+
 /* Alarms */
 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, 
char *buf)
 {
@@ -664,17 +808,40 @@ static ssize_t show_alarms(struct device
 }
 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
 
+static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
+               char *buf)
+{
+       int bitnr = to_sensor_dev_attr(attr)->index;
+       struct it87_data *data = it87_update_device(dev);
+       return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
+}
+static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 8);
+static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 9);
+static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 10);
+static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 11);
+static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 12);
+static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 13);
+static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 14);
+static SENSOR_DEVICE_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 15);
+static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 0);
+static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 1);
+static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 2);
+static SENSOR_DEVICE_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 3);
+static SENSOR_DEVICE_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL, 6);
+static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 16);
+static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 17);
+static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 18);
+
 static ssize_t
 show_vrm_reg(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       struct it87_data *data = it87_update_device(dev);
+       struct it87_data *data = dev_get_drvdata(dev);
        return sprintf(buf, "%u\n", data->vrm);
 }
 static ssize_t
 store_vrm_reg(struct device *dev, struct device_attribute *attr, const char 
*buf, size_t count)
 {
-       struct i2c_client *client = to_i2c_client(dev);
-       struct it87_data *data = i2c_get_clientdata(client);
+       struct it87_data *data = dev_get_drvdata(dev);
        u32 val;
 
        val = simple_strtoul(buf, NULL, 10);
@@ -683,8 +850,6 @@ store_vrm_reg(struct device *dev, struct
        return count;
 }
 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg);
-#define device_create_file_vrm(client) \
-device_create_file(&client->dev, &dev_attr_vrm)
 
 static ssize_t
 show_vid_reg(struct device *dev, struct device_attribute *attr, char *buf)
@@ -693,37 +858,159 @@ show_vid_reg(struct device *dev, struct 
        return sprintf(buf, "%ld\n", (long) vid_from_reg(data->vid, data->vrm));
 }
 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL);
-#define device_create_file_vid(client) \
-device_create_file(&client->dev, &dev_attr_cpu0_vid)
-
-/* This function is called when:
-     * it87_driver is inserted (when this module is loaded), for each
-       available adapter
-     * when a new adapter is inserted (and it87_driver is still present) */
-static int it87_attach_adapter(struct i2c_adapter *adapter)
-{
-       if (!(adapter->class & I2C_CLASS_HWMON))
-               return 0;
-       return i2c_probe(adapter, &addr_data, it87_detect);
-}
-
-static int it87_isa_attach_adapter(struct i2c_adapter *adapter)
-{
-       return it87_detect(adapter, isa_address, -1);
-}
+
+static ssize_t show_name(struct device *dev, struct device_attribute
+                        *devattr, char *buf)
+{
+       struct it87_data *data = dev_get_drvdata(dev);
+       return sprintf(buf, "%s\n", data->name);
+}
+static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
+
+static struct attribute *it87_attributes[] = {
+       &sensor_dev_attr_in0_input.dev_attr.attr,
+       &sensor_dev_attr_in1_input.dev_attr.attr,
+       &sensor_dev_attr_in2_input.dev_attr.attr,
+       &sensor_dev_attr_in3_input.dev_attr.attr,
+       &sensor_dev_attr_in4_input.dev_attr.attr,
+       &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_in0_min.dev_attr.attr,
+       &sensor_dev_attr_in1_min.dev_attr.attr,
+       &sensor_dev_attr_in2_min.dev_attr.attr,
+       &sensor_dev_attr_in3_min.dev_attr.attr,
+       &sensor_dev_attr_in4_min.dev_attr.attr,
+       &sensor_dev_attr_in5_min.dev_attr.attr,
+       &sensor_dev_attr_in6_min.dev_attr.attr,
+       &sensor_dev_attr_in7_min.dev_attr.attr,
+       &sensor_dev_attr_in0_max.dev_attr.attr,
+       &sensor_dev_attr_in1_max.dev_attr.attr,
+       &sensor_dev_attr_in2_max.dev_attr.attr,
+       &sensor_dev_attr_in3_max.dev_attr.attr,
+       &sensor_dev_attr_in4_max.dev_attr.attr,
+       &sensor_dev_attr_in5_max.dev_attr.attr,
+       &sensor_dev_attr_in6_max.dev_attr.attr,
+       &sensor_dev_attr_in7_max.dev_attr.attr,
+       &sensor_dev_attr_in0_alarm.dev_attr.attr,
+       &sensor_dev_attr_in1_alarm.dev_attr.attr,
+       &sensor_dev_attr_in2_alarm.dev_attr.attr,
+       &sensor_dev_attr_in3_alarm.dev_attr.attr,
+       &sensor_dev_attr_in4_alarm.dev_attr.attr,
+       &sensor_dev_attr_in5_alarm.dev_attr.attr,
+       &sensor_dev_attr_in6_alarm.dev_attr.attr,
+       &sensor_dev_attr_in7_alarm.dev_attr.attr,
+
+       &sensor_dev_attr_temp1_input.dev_attr.attr,
+       &sensor_dev_attr_temp2_input.dev_attr.attr,
+       &sensor_dev_attr_temp3_input.dev_attr.attr,
+       &sensor_dev_attr_temp1_max.dev_attr.attr,
+       &sensor_dev_attr_temp2_max.dev_attr.attr,
+       &sensor_dev_attr_temp3_max.dev_attr.attr,
+       &sensor_dev_attr_temp1_min.dev_attr.attr,
+       &sensor_dev_attr_temp2_min.dev_attr.attr,
+       &sensor_dev_attr_temp3_min.dev_attr.attr,
+       &sensor_dev_attr_temp1_type.dev_attr.attr,
+       &sensor_dev_attr_temp2_type.dev_attr.attr,
+       &sensor_dev_attr_temp3_type.dev_attr.attr,
+       &sensor_dev_attr_temp1_alarm.dev_attr.attr,
+       &sensor_dev_attr_temp2_alarm.dev_attr.attr,
+       &sensor_dev_attr_temp3_alarm.dev_attr.attr,
+
+       &dev_attr_alarms.attr,
+       &dev_attr_name.attr,
+       NULL
+};
+
+static const struct attribute_group it87_group = {
+       .attrs = it87_attributes,
+};
+
+static struct attribute *it87_attributes_opt[] = {
+       &sensor_dev_attr_fan1_input16.dev_attr.attr,
+       &sensor_dev_attr_fan1_min16.dev_attr.attr,
+       &sensor_dev_attr_fan2_input16.dev_attr.attr,
+       &sensor_dev_attr_fan2_min16.dev_attr.attr,
+       &sensor_dev_attr_fan3_input16.dev_attr.attr,
+       &sensor_dev_attr_fan3_min16.dev_attr.attr,
+       &sensor_dev_attr_fan4_input16.dev_attr.attr,
+       &sensor_dev_attr_fan4_min16.dev_attr.attr,
+       &sensor_dev_attr_fan5_input16.dev_attr.attr,
+       &sensor_dev_attr_fan5_min16.dev_attr.attr,
+
+       &sensor_dev_attr_fan1_input.dev_attr.attr,
+       &sensor_dev_attr_fan1_min.dev_attr.attr,
+       &sensor_dev_attr_fan1_div.dev_attr.attr,
+       &sensor_dev_attr_fan2_input.dev_attr.attr,
+       &sensor_dev_attr_fan2_min.dev_attr.attr,
+       &sensor_dev_attr_fan2_div.dev_attr.attr,
+       &sensor_dev_attr_fan3_input.dev_attr.attr,
+       &sensor_dev_attr_fan3_min.dev_attr.attr,
+       &sensor_dev_attr_fan3_div.dev_attr.attr,
+
+       &sensor_dev_attr_fan1_alarm.dev_attr.attr,
+       &sensor_dev_attr_fan2_alarm.dev_attr.attr,
+       &sensor_dev_attr_fan3_alarm.dev_attr.attr,
+       &sensor_dev_attr_fan4_alarm.dev_attr.attr,
+       &sensor_dev_attr_fan5_alarm.dev_attr.attr,
+
+       &sensor_dev_attr_pwm1_enable.dev_attr.attr,
+       &sensor_dev_attr_pwm2_enable.dev_attr.attr,
+       &sensor_dev_attr_pwm3_enable.dev_attr.attr,
+       &sensor_dev_attr_pwm1.dev_attr.attr,
+       &sensor_dev_attr_pwm2.dev_attr.attr,
+       &sensor_dev_attr_pwm3.dev_attr.attr,
+       &dev_attr_pwm1_freq.attr,
+       &dev_attr_pwm2_freq.attr,
+       &dev_attr_pwm3_freq.attr,
+
+       &dev_attr_vrm.attr,
+       &dev_attr_cpu0_vid.attr,
+       NULL
+};
+
+static const struct attribute_group it87_group_opt = {
+       .attrs = it87_attributes_opt,
+};
 
 /* SuperIO detection - will change isa_address if a chip is found */
-static int __init it87_find(unsigned short *address)
+static int __init it87_find(unsigned short *address,
+       struct it87_sio_data *sio_data)
 {
        int err = -ENODEV;
+       u16 chip_type;
+       const char *board_vendor, *board_name;
 
        superio_enter();
-       chip_type = superio_inw(DEVID);
-       if (chip_type != IT8712F_DEVID
-        && chip_type != IT8705F_DEVID)
-               goto exit;
-
-       superio_select();
+       chip_type = force_id ? force_id : superio_inw(DEVID);
+
+       switch (chip_type) {
+       case IT8705F_DEVID:
+               sio_data->type = it87;
+               break;
+       case IT8712F_DEVID:
+               sio_data->type = it8712;
+               break;
+       case IT8716F_DEVID:
+       case IT8726F_DEVID:
+               sio_data->type = it8716;
+               break;
+       case IT8718F_DEVID:
+               sio_data->type = it8718;
+               break;
+       case IT8720F_DEVID:
+               sio_data->type = it8720;
+               break;
+       case 0xffff:    /* No device at all */
+               goto exit;
+       default:
+               pr_debug(DRVNAME ": Unsupported chip (DEVID=0x%x)\n",
+                        chip_type);
+               goto exit;
+       }
+
+       superio_select(PME);
        if (!(superio_inb(IT87_ACT_REG) & 0x01)) {
                pr_info("it87: Device not activated, skipping\n");
                goto exit;
@@ -736,255 +1023,293 @@ static int __init it87_find(unsigned sho
        }
 
        err = 0;
+       sio_data->revision = superio_inb(DEVREV) & 0x0f;
        pr_info("it87: Found IT%04xF chip at 0x%x, revision %d\n",
-               chip_type, *address, superio_inb(DEVREV) & 0x0f);
+               chip_type, *address, sio_data->revision);
+
+       /* Read GPIO config and VID value from LDN 7 (GPIO) */
+       if (chip_type != IT8705F_DEVID) {
+               int reg;
+
+               superio_select(GPIO);
+               if ((chip_type == it8718) ||
+                   (chip_type == it8720))
+                       sio_data->vid_value = superio_inb(IT87_SIO_VID_REG);
+
+               reg = superio_inb(IT87_SIO_PINX2_REG);
+               if (reg & (1 << 0))
+                       pr_info("it87: in3 is VCC (+5V)\n");
+               if (reg & (1 << 1))
+                       pr_info("it87: in7 is VCCH (+5V Stand-By)\n");
+       }
+
+       /* Disable specific features based on DMI strings */
+       board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
+       board_name = dmi_get_system_info(DMI_BOARD_NAME);
+       if (board_vendor && board_name) {
+               if (strcmp(board_vendor, "nVIDIA") == 0
+                && strcmp(board_name, "FN68PT") == 0) {
+                       /* On the Shuttle SN68PT, FAN_CTL2 is apparently not
+                          connected to a fan, but to something else. One user
+                          has reported instant system power-off when changing
+                          the PWM2 duty cycle, so we disable it.
+                          I use the board name string as the trigger in case
+                          the same board is ever used in other systems. */
+                       pr_info("it87: Disabling pwm2 due to "
+                               "hardware constraints\n");
+                       sio_data->skip_pwm = (1 << 1);
+               }
+       }
 
 exit:
        superio_exit();
        return err;
 }
 
-/* This function is called by i2c_probe */
-static int it87_detect(struct i2c_adapter *adapter, int address, int kind)
-{
-       int i;
-       struct i2c_client *new_client;
+static int __devinit it87_probe(struct platform_device *pdev)
+{
        struct it87_data *data;
+       struct resource *res;
+       struct device *dev = &pdev->dev;
+       struct it87_sio_data *sio_data = dev->platform_data;
        int err = 0;
-       const char *name = "";
-       int is_isa = i2c_is_isa_adapter(adapter);
        int enable_pwm_interface;
-
-       if (!is_isa && 
-           !i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
+       static const char *names[] = {
+               "it87",
+               "it8712",
+               "it8716",
+               "it8718",
+               "it8720",
+       };
+
+       res = platform_get_resource(pdev, IORESOURCE_IO, 0);
+       if (!request_region(res->start, IT87_EC_EXTENT, DRVNAME)) {
+               dev_err(dev, "Failed to request region 0x%lx-0x%lx\n",
+                       (unsigned long)res->start,
+                       (unsigned long)(res->start + IT87_EC_EXTENT - 1));
+               err = -EBUSY;
                goto ERROR0;
-
-       /* Reserve the ISA region */
-       if (is_isa)
-               if (!request_region(address, IT87_EXTENT,
-                                   it87_isa_driver.driver.name))
-                       goto ERROR0;
-
-       /* For now, we presume we have a valid client. We create the
-          client structure, even though we cannot fill it completely yet.
-          But it allows us to access it87_{read,write}_value. */
+       }
 
        if (!(data = kzalloc(sizeof(struct it87_data), GFP_KERNEL))) {
                err = -ENOMEM;
                goto ERROR1;
        }
 
-       new_client = &data->client;
-       if (is_isa)
-               mutex_init(&data->lock);
-       i2c_set_clientdata(new_client, data);
-       new_client->addr = address;
-       new_client->adapter = adapter;
-       new_client->driver = is_isa ? &it87_isa_driver : &it87_driver;
-       new_client->flags = 0;
+       data->addr = res->start;
+       data->type = sio_data->type;
+       data->revision = sio_data->revision;
+       data->name = names[sio_data->type];
 
        /* Now, we do the remaining detection. */
-
-       if (kind < 0) {
-               if ((it87_read_value(new_client, IT87_REG_CONFIG) & 0x80)
-                 || (!is_isa
-                  && it87_read_value(new_client, IT87_REG_I2C_ADDR) != 
address)) {
-                       err = -ENODEV;
-                       goto ERROR2;
-               }
-       }
-
-       /* Determine the chip type. */
-       if (kind <= 0) {
-               i = it87_read_value(new_client, IT87_REG_CHIPID);
-               if (i == 0x90) {
-                       kind = it87;
-                       if ((is_isa) && (chip_type == IT8712F_DEVID))
-                               kind = it8712;
-               }
-               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), address);
-                       err = -ENODEV;
-                       goto ERROR2;
-               }
-       }
-
-       if (kind == it87) {
-               name = "it87";
-       } else if (kind == it8712) {
-               name = "it8712";
-       }
-
-       /* Fill in the remaining client fields and put it into the global list 
*/
-       strlcpy(new_client->name, name, I2C_NAME_SIZE);
-       data->type = kind;
-       data->valid = 0;
+       if ((it87_read_value(data, IT87_REG_CONFIG) & 0x80)
+        || it87_read_value(data, IT87_REG_CHIPID) != 0x90) {
+               err = -ENODEV;
+               goto ERROR2;
+       }
+
+       platform_set_drvdata(pdev, data);
+
        mutex_init(&data->update_lock);
 
-       /* Tell the I2C layer a new client has arrived */
-       if ((err = i2c_attach_client(new_client)))
+       /* Check PWM configuration */
+       enable_pwm_interface = it87_check_pwm(dev);
+
+       /* Initialize the IT87 chip */
+       it87_init_device(pdev);
+
+       /* Register sysfs hooks */
+       if ((err = sysfs_create_group(&dev->kobj, &it87_group)))
                goto ERROR2;
 
-       if (!is_isa)
-               dev_info(&new_client->dev, "The I2C interface to IT87xxF "
-                        "hardware monitoring chips is deprecated. Please "
-                        "report if you still rely on it.\n");
-
-       /* Check PWM configuration */
-       enable_pwm_interface = it87_check_pwm(new_client);
-
-       /* Initialize the IT87 chip */
-       it87_init_client(new_client, data);
-
-       /* Register sysfs hooks */
-       data->class_dev = hwmon_device_register(&new_client->dev);
-       if (IS_ERR(data->class_dev)) {
-               err = PTR_ERR(data->class_dev);
-               goto ERROR3;
-       }
-
-       device_create_file(&new_client->dev, 
&sensor_dev_attr_in0_input.dev_attr);
-       device_create_file(&new_client->dev, 
&sensor_dev_attr_in1_input.dev_attr);
-       device_create_file(&new_client->dev, 
&sensor_dev_attr_in2_input.dev_attr);
-       device_create_file(&new_client->dev, 
&sensor_dev_attr_in3_input.dev_attr);
-       device_create_file(&new_client->dev, 
&sensor_dev_attr_in4_input.dev_attr);
-       device_create_file(&new_client->dev, 
&sensor_dev_attr_in5_input.dev_attr);
-       device_create_file(&new_client->dev, 
&sensor_dev_attr_in6_input.dev_attr);
-       device_create_file(&new_client->dev, 
&sensor_dev_attr_in7_input.dev_attr);
-       device_create_file(&new_client->dev, 
&sensor_dev_attr_in8_input.dev_attr);
-       device_create_file(&new_client->dev, &sensor_dev_attr_in0_min.dev_attr);
-       device_create_file(&new_client->dev, &sensor_dev_attr_in1_min.dev_attr);
-       device_create_file(&new_client->dev, &sensor_dev_attr_in2_min.dev_attr);
-       device_create_file(&new_client->dev, &sensor_dev_attr_in3_min.dev_attr);
-       device_create_file(&new_client->dev, &sensor_dev_attr_in4_min.dev_attr);
-       device_create_file(&new_client->dev, &sensor_dev_attr_in5_min.dev_attr);
-       device_create_file(&new_client->dev, &sensor_dev_attr_in6_min.dev_attr);
-       device_create_file(&new_client->dev, &sensor_dev_attr_in7_min.dev_attr);
-       device_create_file(&new_client->dev, &sensor_dev_attr_in0_max.dev_attr);
-       device_create_file(&new_client->dev, &sensor_dev_attr_in1_max.dev_attr);
-       device_create_file(&new_client->dev, &sensor_dev_attr_in2_max.dev_attr);
-       device_create_file(&new_client->dev, &sensor_dev_attr_in3_max.dev_attr);
-       device_create_file(&new_client->dev, &sensor_dev_attr_in4_max.dev_attr);
-       device_create_file(&new_client->dev, &sensor_dev_attr_in5_max.dev_attr);
-       device_create_file(&new_client->dev, &sensor_dev_attr_in6_max.dev_attr);
-       device_create_file(&new_client->dev, &sensor_dev_attr_in7_max.dev_attr);
-       device_create_file(&new_client->dev, 
&sensor_dev_attr_temp1_input.dev_attr);
-       device_create_file(&new_client->dev, 
&sensor_dev_attr_temp2_input.dev_attr);
-       device_create_file(&new_client->dev, 
&sensor_dev_attr_temp3_input.dev_attr);
-       device_create_file(&new_client->dev, 
&sensor_dev_attr_temp1_max.dev_attr);
-       device_create_file(&new_client->dev, 
&sensor_dev_attr_temp2_max.dev_attr);
-       device_create_file(&new_client->dev, 
&sensor_dev_attr_temp3_max.dev_attr);
-       device_create_file(&new_client->dev, 
&sensor_dev_attr_temp1_min.dev_attr);
-       device_create_file(&new_client->dev, 
&sensor_dev_attr_temp2_min.dev_attr);
-       device_create_file(&new_client->dev, 
&sensor_dev_attr_temp3_min.dev_attr);
-       device_create_file(&new_client->dev, 
&sensor_dev_attr_temp1_type.dev_attr);
-       device_create_file(&new_client->dev, 
&sensor_dev_attr_temp2_type.dev_attr);
-       device_create_file(&new_client->dev, 
&sensor_dev_attr_temp3_type.dev_attr);
-       device_create_file(&new_client->dev, 
&sensor_dev_attr_fan1_input.dev_attr);
-       device_create_file(&new_client->dev, 
&sensor_dev_attr_fan2_input.dev_attr);
-       device_create_file(&new_client->dev, 
&sensor_dev_attr_fan3_input.dev_attr);
-       device_create_file(&new_client->dev, 
&sensor_dev_attr_fan1_min.dev_attr);
-       device_create_file(&new_client->dev, 
&sensor_dev_attr_fan2_min.dev_attr);
-       device_create_file(&new_client->dev, 
&sensor_dev_attr_fan3_min.dev_attr);
-       device_create_file(&new_client->dev, 
&sensor_dev_attr_fan1_div.dev_attr);
-       device_create_file(&new_client->dev, 
&sensor_dev_attr_fan2_div.dev_attr);
-       device_create_file(&new_client->dev, 
&sensor_dev_attr_fan3_div.dev_attr);
-       device_create_file(&new_client->dev, &dev_attr_alarms);
+       /* Do not create fan files for disabled fans */
+       if (has_16bit_fans(data)) {
+               /* 16-bit tachometers */
+               if (data->has_fan & (1 << 0)) {
+                       if ((err = device_create_file(dev,
+                            &sensor_dev_attr_fan1_input16.dev_attr))
+                        || (err = device_create_file(dev,
+                            &sensor_dev_attr_fan1_min16.dev_attr))
+                        || (err = device_create_file(dev,
+                            &sensor_dev_attr_fan1_alarm.dev_attr)))
+                               goto ERROR4;
+               }
+               if (data->has_fan & (1 << 1)) {
+                       if ((err = device_create_file(dev,
+                            &sensor_dev_attr_fan2_input16.dev_attr))
+                        || (err = device_create_file(dev,
+                            &sensor_dev_attr_fan2_min16.dev_attr))
+                        || (err = device_create_file(dev,
+                            &sensor_dev_attr_fan2_alarm.dev_attr)))
+                               goto ERROR4;
+               }
+               if (data->has_fan & (1 << 2)) {
+                       if ((err = device_create_file(dev,
+                            &sensor_dev_attr_fan3_input16.dev_attr))
+                        || (err = device_create_file(dev,
+                            &sensor_dev_attr_fan3_min16.dev_attr))
+                        || (err = device_create_file(dev,
+                            &sensor_dev_attr_fan3_alarm.dev_attr)))
+                               goto ERROR4;
+               }
+               if (data->has_fan & (1 << 3)) {
+                       if ((err = device_create_file(dev,
+                            &sensor_dev_attr_fan4_input16.dev_attr))
+                        || (err = device_create_file(dev,
+                            &sensor_dev_attr_fan4_min16.dev_attr))
+                        || (err = device_create_file(dev,
+                            &sensor_dev_attr_fan4_alarm.dev_attr)))
+                               goto ERROR4;
+               }
+               if (data->has_fan & (1 << 4)) {
+                       if ((err = device_create_file(dev,
+                            &sensor_dev_attr_fan5_input16.dev_attr))
+                        || (err = device_create_file(dev,
+                            &sensor_dev_attr_fan5_min16.dev_attr))
+                        || (err = device_create_file(dev,
+                            &sensor_dev_attr_fan5_alarm.dev_attr)))
+                               goto ERROR4;
+               }
+       } else {
+               /* 8-bit tachometers with clock divider */
+               if (data->has_fan & (1 << 0)) {
+                       if ((err = device_create_file(dev,
+                            &sensor_dev_attr_fan1_input.dev_attr))
+                        || (err = device_create_file(dev,
+                            &sensor_dev_attr_fan1_min.dev_attr))
+                        || (err = device_create_file(dev,
+                            &sensor_dev_attr_fan1_div.dev_attr))
+                        || (err = device_create_file(dev,
+                            &sensor_dev_attr_fan1_alarm.dev_attr)))
+                               goto ERROR4;
+               }
+               if (data->has_fan & (1 << 1)) {
+                       if ((err = device_create_file(dev,
+                            &sensor_dev_attr_fan2_input.dev_attr))
+                        || (err = device_create_file(dev,
+                            &sensor_dev_attr_fan2_min.dev_attr))
+                        || (err = device_create_file(dev,
+                            &sensor_dev_attr_fan2_div.dev_attr))
+                        || (err = device_create_file(dev,
+                            &sensor_dev_attr_fan2_alarm.dev_attr)))
+                               goto ERROR4;
+               }
+               if (data->has_fan & (1 << 2)) {
+                       if ((err = device_create_file(dev,
+                            &sensor_dev_attr_fan3_input.dev_attr))
+                        || (err = device_create_file(dev,
+                            &sensor_dev_attr_fan3_min.dev_attr))
+                        || (err = device_create_file(dev,
+                            &sensor_dev_attr_fan3_div.dev_attr))
+                        || (err = device_create_file(dev,
+                            &sensor_dev_attr_fan3_alarm.dev_attr)))
+                               goto ERROR4;
+               }
+       }
+
        if (enable_pwm_interface) {
-               device_create_file(&new_client->dev, 
&sensor_dev_attr_pwm1_enable.dev_attr);
-               device_create_file(&new_client->dev, 
&sensor_dev_attr_pwm2_enable.dev_attr);
-               device_create_file(&new_client->dev, 
&sensor_dev_attr_pwm3_enable.dev_attr);
-               device_create_file(&new_client->dev, 
&sensor_dev_attr_pwm1.dev_attr);
-               device_create_file(&new_client->dev, 
&sensor_dev_attr_pwm2.dev_attr);
-               device_create_file(&new_client->dev, 
&sensor_dev_attr_pwm3.dev_attr);
-       }
-
-       if (data->type == it8712) {
+               if (!(sio_data->skip_pwm & (1 << 0))) {
+                       if ((err = device_create_file(dev,
+                            &sensor_dev_attr_pwm1_enable.dev_attr))
+                        || (err = device_create_file(dev,
+                            &sensor_dev_attr_pwm1.dev_attr))
+                        || (err = device_create_file(dev,
+                            &dev_attr_pwm1_freq)))
+                               goto ERROR4;
+               }
+               if (!(sio_data->skip_pwm & (1 << 1))) {
+                       if ((err = device_create_file(dev,
+                            &sensor_dev_attr_pwm2_enable.dev_attr))
+                        || (err = device_create_file(dev,
+                            &sensor_dev_attr_pwm2.dev_attr))
+                        || (err = device_create_file(dev,
+                            &dev_attr_pwm2_freq)))
+                               goto ERROR4;
+               }
+               if (!(sio_data->skip_pwm & (1 << 2))) {
+                       if ((err = device_create_file(dev,
+                            &sensor_dev_attr_pwm3_enable.dev_attr))
+                        || (err = device_create_file(dev,
+                            &sensor_dev_attr_pwm3.dev_attr))
+                        || (err = device_create_file(dev,
+                            &dev_attr_pwm3_freq)))
+                               goto ERROR4;
+               }
+       }
+
+       if (data->type == it8712 || data->type == it8716
+        || data->type == it8718 || data->type == it8720) {
                data->vrm = vid_which_vrm();
-               device_create_file_vrm(new_client);
-               device_create_file_vid(new_client);
+               /* VID reading from Super-I/O config space if available */
+               data->vid = sio_data->vid_value;
+               if ((err = device_create_file(dev,
+                    &dev_attr_vrm))
+                || (err = device_create_file(dev,
+                    &dev_attr_cpu0_vid)))
+                       goto ERROR4;
+       }
+
+       data->hwmon_dev = hwmon_device_register(dev);
+       if (IS_ERR(data->hwmon_dev)) {
+               err = PTR_ERR(data->hwmon_dev);
+               goto ERROR4;
        }
 
        return 0;
 
-ERROR3:
-       i2c_detach_client(new_client);
+ERROR4:
+       sysfs_remove_group(&dev->kobj, &it87_group);
+       sysfs_remove_group(&dev->kobj, &it87_group_opt);
 ERROR2:
+       platform_set_drvdata(pdev, NULL);
        kfree(data);
 ERROR1:
-       if (is_isa)
-               release_region(address, IT87_EXTENT);
+       release_region(res->start, IT87_EC_EXTENT);
 ERROR0:
        return err;
 }
 
-static int it87_detach_client(struct i2c_client *client)
-{
-       struct it87_data *data = i2c_get_clientdata(client);
-       int err;
-
-       hwmon_device_unregister(data->class_dev);
-
-       if ((err = i2c_detach_client(client)))
-               return err;
-
-       if(i2c_is_isa_client(client))
-               release_region(client->addr, IT87_EXTENT);
+static int __devexit it87_remove(struct platform_device *pdev)
+{
+       struct it87_data *data = platform_get_drvdata(pdev);
+
+       hwmon_device_unregister(data->hwmon_dev);
+       sysfs_remove_group(&pdev->dev.kobj, &it87_group);
+       sysfs_remove_group(&pdev->dev.kobj, &it87_group_opt);
+
+       release_region(data->addr, IT87_EC_EXTENT);
+       platform_set_drvdata(pdev, NULL);
        kfree(data);
 
        return 0;
 }
 
-/* The SMBus locks itself, but ISA access must be locked explicitly! 
-   We don't want to lock the whole ISA bus, so we lock each client
-   separately.
+/* Must be called with data->update_lock held, except during initialization.
    We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
    would slow down the IT87 access and should not be necessary. */
-static int it87_read_value(struct i2c_client *client, u8 reg)
-{
-       struct it87_data *data = i2c_get_clientdata(client);
-
-       int res;
-       if (i2c_is_isa_client(client)) {
-               mutex_lock(&data->lock);
-               outb_p(reg, client->addr + IT87_ADDR_REG_OFFSET);
-               res = inb_p(client->addr + IT87_DATA_REG_OFFSET);
-               mutex_unlock(&data->lock);
-               return res;
-       } else
-               return i2c_smbus_read_byte_data(client, reg);
-}
-
-/* The SMBus locks itself, but ISA access muse be locked explicitly! 
-   We don't want to lock the whole ISA bus, so we lock each client
-   separately.
+static int it87_read_value(struct it87_data *data, u8 reg)
+{
+       outb_p(reg, data->addr + IT87_ADDR_REG_OFFSET);
+       return inb_p(data->addr + IT87_DATA_REG_OFFSET);
+}
+
+/* Must be called with data->update_lock held, except during initialization.
    We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks,
    would slow down the IT87 access and should not be necessary. */
-static int it87_write_value(struct i2c_client *client, u8 reg, u8 value)
-{
-       struct it87_data *data = i2c_get_clientdata(client);
-
-       if (i2c_is_isa_client(client)) {
-               mutex_lock(&data->lock);
-               outb_p(reg, client->addr + IT87_ADDR_REG_OFFSET);
-               outb_p(value, client->addr + IT87_DATA_REG_OFFSET);
-               mutex_unlock(&data->lock);
-               return 0;
-       } else
-               return i2c_smbus_write_byte_data(client, reg, value);
+static void it87_write_value(struct it87_data *data, u8 reg, u8 value)
+{
+       outb_p(reg, data->addr + IT87_ADDR_REG_OFFSET);
+       outb_p(value, data->addr + IT87_DATA_REG_OFFSET);
 }
 
 /* Return 1 if and only if the PWM interface is safe to use */
-static int it87_check_pwm(struct i2c_client *client)
-{
+static int __devinit it87_check_pwm(struct device *dev)
+{
+       struct it87_data *data = dev_get_drvdata(dev);
        /* Some BIOSes fail to correctly configure the IT87 fans. All fans off
         * and polarity set to active low is sign that this is the case so we
         * disable pwm control to protect the user. */
-       int tmp = it87_read_value(client, IT87_REG_FAN_CTL);
+       int tmp = it87_read_value(data, IT87_REG_FAN_CTL);
        if ((tmp & 0x87) == 0) {
                if (fix_pwm_polarity) {
                        /* The user asks us to attempt a chip reconfiguration.
@@ -994,7 +1319,7 @@ static int it87_check_pwm(struct i2c_cli
                        u8 pwm[3];
 
                        for (i = 0; i < 3; i++)
-                               pwm[i] = it87_read_value(client,
+                               pwm[i] = it87_read_value(data,
                                                         IT87_REG_PWM(i));
 
                        /* If any fan is in automatic pwm mode, the polarity
@@ -1002,26 +1327,26 @@ static int it87_check_pwm(struct i2c_cli
                         * better don't change anything (but still disable the
                         * PWM interface). */
                        if (!((pwm[0] | pwm[1] | pwm[2]) & 0x80)) {
-                               dev_info(&client->dev, "Reconfiguring PWM to "
+                               dev_info(dev, "Reconfiguring PWM to "
                                         "active high polarity\n");
-                               it87_write_value(client, IT87_REG_FAN_CTL,
+                               it87_write_value(data, IT87_REG_FAN_CTL,
                                                 tmp | 0x87);
                                for (i = 0; i < 3; i++)
-                                       it87_write_value(client,
+                                       it87_write_value(data,
                                                         IT87_REG_PWM(i),
                                                         0x7f & ~pwm[i]);
                                return 1;
                        }
 
-                       dev_info(&client->dev, "PWM configuration is "
+                       dev_info(dev, "PWM configuration is "
                                 "too broken to be fixed\n");
                }
 
-               dev_info(&client->dev, "Detected broken BIOS "
+               dev_info(dev, "Detected broken BIOS "
                         "defaults, disabling PWM interface\n");
                return 0;
        } else if (fix_pwm_polarity) {
-               dev_info(&client->dev, "PWM configuration looks "
+               dev_info(dev, "PWM configuration looks "
                         "sane, won't touch\n");
        }
 
@@ -1029,8 +1354,9 @@ static int it87_check_pwm(struct i2c_cli
 }
 
 /* Called when we have found a new IT87. */
-static void it87_init_client(struct i2c_client *client, struct it87_data *data)
-{
+static void __devinit it87_init_device(struct platform_device *pdev)
+{
+       struct it87_data *data = platform_get_drvdata(pdev);
        int tmp, i;
 
        /* initialize to sane defaults:
@@ -1044,28 +1370,63 @@ static void it87_init_client(struct i2c_
                data->manual_pwm_ctl[i] = 0xff;
        }
 
-       /* Check if temperature channnels are reset manually or by some reason 
*/
-       tmp = it87_read_value(client, IT87_REG_TEMP_ENABLE);
+       /* Some chips seem to have default value 0xff for all limit
+        * registers. For low voltage limits it makes no sense and triggers
+        * alarms, so change to 0 instead. For high temperature limits, it
+        * means -1 degree C, which surprisingly doesn't trigger an alarm,
+        * but is still confusing, so change to 127 degrees C. */
+       for (i = 0; i < 8; i++) {
+               tmp = it87_read_value(data, IT87_REG_VIN_MIN(i));
+               if (tmp == 0xff)
+                       it87_write_value(data, IT87_REG_VIN_MIN(i), 0);
+       }
+       for (i = 0; i < 3; i++) {
+               tmp = it87_read_value(data, IT87_REG_TEMP_HIGH(i));
+               if (tmp == 0xff)
+                       it87_write_value(data, IT87_REG_TEMP_HIGH(i), 127);
+       }
+
+       /* Check if temperature channels are reset manually or by some reason */
+       tmp = it87_read_value(data, IT87_REG_TEMP_ENABLE);
        if ((tmp & 0x3f) == 0) {
                /* Temp1,Temp3=thermistor; Temp2=thermal diode */
                tmp = (tmp & 0xc0) | 0x2a;
-               it87_write_value(client, IT87_REG_TEMP_ENABLE, tmp);
+               it87_write_value(data, IT87_REG_TEMP_ENABLE, tmp);
        }
        data->sensor = tmp;
 
        /* Check if voltage monitors are reset manually or by some reason */
-       tmp = it87_read_value(client, IT87_REG_VIN_ENABLE);
+       tmp = it87_read_value(data, IT87_REG_VIN_ENABLE);
        if ((tmp & 0xff) == 0) {
                /* Enable all voltage monitors */
-               it87_write_value(client, IT87_REG_VIN_ENABLE, 0xff);
+               it87_write_value(data, IT87_REG_VIN_ENABLE, 0xff);
        }
 
        /* Check if tachometers are reset manually or by some reason */
-       data->fan_main_ctrl = it87_read_value(client, IT87_REG_FAN_MAIN_CTRL);
+       data->fan_main_ctrl = it87_read_value(data, IT87_REG_FAN_MAIN_CTRL);
        if ((data->fan_main_ctrl & 0x70) == 0) {
                /* Enable all fan tachometers */
                data->fan_main_ctrl |= 0x70;
-               it87_write_value(client, IT87_REG_FAN_MAIN_CTRL, 
data->fan_main_ctrl);
+               it87_write_value(data, IT87_REG_FAN_MAIN_CTRL, 
data->fan_main_ctrl);
+       }
+       data->has_fan = (data->fan_main_ctrl >> 4) & 0x07;
+
+       /* Set tachometers to 16-bit mode if needed */
+       if (has_16bit_fans(data)) {
+               tmp = it87_read_value(data, IT87_REG_FAN_16BIT);
+               if (~tmp & 0x07 & data->has_fan) {
+                       dev_dbg(&pdev->dev,
+                               "Setting fan1-3 to 16-bit mode\n");
+                       it87_write_value(data, IT87_REG_FAN_16BIT,
+                                        tmp | 0x07);
+               }
+               /* IT8705F only supports three fans. */
+               if (data->type != it87) {
+                       if (tmp & (1 << 4))
+                               data->has_fan |= (1 << 3); /* fan4 enabled */
+                       if (tmp & (1 << 5))
+                               data->has_fan |= (1 << 4); /* fan5 enabled */
+               }
        }
 
        /* Set current fan mode registers and the default settings for the
@@ -1073,7 +1434,7 @@ static void it87_init_client(struct i2c_
        for (i = 0; i < 3; i++) {
                if (data->fan_main_ctrl & (1 << i)) {
                        /* pwm mode */
-                       tmp = it87_read_value(client, IT87_REG_PWM(i));
+                       tmp = it87_read_value(data, IT87_REG_PWM(i));
                        if (tmp & 0x80) {
                                /* automatic pwm - not yet implemented, but
                                 * leave the settings made by the BIOS alone
@@ -1087,15 +1448,14 @@ static void it87_init_client(struct i2c_
        }
 
        /* Start monitoring */
-       it87_write_value(client, IT87_REG_CONFIG,
-                        (it87_read_value(client, IT87_REG_CONFIG) & 0x36)
+       it87_write_value(data, IT87_REG_CONFIG,
+                        (it87_read_value(data, IT87_REG_CONFIG) & 0x36)
                         | (update_vbat ? 0x41 : 0x01));
 }
 
 static struct it87_data *it87_update_device(struct device *dev)
 {
-       struct i2c_client *client = to_i2c_client(dev);
-       struct it87_data *data = i2c_get_clientdata(client);
+       struct it87_data *data = dev_get_drvdata(dev);
        int i;
 
        mutex_lock(&data->update_lock);
@@ -1106,55 +1466,72 @@ static struct it87_data *it87_update_dev
                if (update_vbat) {
                        /* Cleared after each update, so reenable.  Value
                          returned by this read will be previous value */       
-                       it87_write_value(client, IT87_REG_CONFIG,
-                          it87_read_value(client, IT87_REG_CONFIG) | 0x40);
+                       it87_write_value(data, IT87_REG_CONFIG,
+                          it87_read_value(data, IT87_REG_CONFIG) | 0x40);
                }
                for (i = 0; i <= 7; i++) {
                        data->in[i] =
-                           it87_read_value(client, IT87_REG_VIN(i));
+                           it87_read_value(data, IT87_REG_VIN(i));
                        data->in_min[i] =
-                           it87_read_value(client, IT87_REG_VIN_MIN(i));
+                           it87_read_value(data, IT87_REG_VIN_MIN(i));
                        data->in_max[i] =
-                           it87_read_value(client, IT87_REG_VIN_MAX(i));
-               }
+                           it87_read_value(data, IT87_REG_VIN_MAX(i));
+               }
+               /* in8 (battery) has no limit registers */
                data->in[8] =
-                   it87_read_value(client, IT87_REG_VIN(8));
-               /* Temperature sensor doesn't have limit registers, set
-                  to min and max value */
-               data->in_min[8] = 0;
-               data->in_max[8] = 255;
-
-               for (i = 0; i < 3; i++) {
-                       data->fan[i] =
-                           it87_read_value(client, IT87_REG_FAN(i));
+                   it87_read_value(data, IT87_REG_VIN(8));
+
+               for (i = 0; i < 5; i++) {
+                       /* Skip disabled fans */
+                       if (!(data->has_fan & (1 << i)))
+                               continue;
+
                        data->fan_min[i] =
-                           it87_read_value(client, IT87_REG_FAN_MIN(i));
+                           it87_read_value(data, IT87_REG_FAN_MIN[i]);
+                       data->fan[i] = it87_read_value(data,
+                                      IT87_REG_FAN[i]);
+                       /* Add high byte if in 16-bit mode */
+                       if (has_16bit_fans(data)) {
+                               data->fan[i] |= it87_read_value(data,
+                                               IT87_REG_FANX[i]) << 8;
+                               data->fan_min[i] |= it87_read_value(data,
+                                               IT87_REG_FANX_MIN[i]) << 8;
+                       }
                }
                for (i = 0; i < 3; i++) {
                        data->temp[i] =
-                           it87_read_value(client, IT87_REG_TEMP(i));
+                           it87_read_value(data, IT87_REG_TEMP(i));
                        data->temp_high[i] =
-                           it87_read_value(client, IT87_REG_TEMP_HIGH(i));
+                           it87_read_value(data, IT87_REG_TEMP_HIGH(i));
                        data->temp_low[i] =
-                           it87_read_value(client, IT87_REG_TEMP_LOW(i));
-               }
-
-               i = it87_read_value(client, IT87_REG_FAN_DIV);
-               data->fan_div[0] = i & 0x07;
-               data->fan_div[1] = (i >> 3) & 0x07;
-               data->fan_div[2] = (i & 0x40) ? 3 : 1;
+                           it87_read_value(data, IT87_REG_TEMP_LOW(i));
+               }
+
+               /* Newer chips don't have clock dividers */
+               if ((data->has_fan & 0x07) && !has_16bit_fans(data)) {
+                       i = it87_read_value(data, IT87_REG_FAN_DIV);
+                       data->fan_div[0] = i & 0x07;
+                       data->fan_div[1] = (i >> 3) & 0x07;
+                       data->fan_div[2] = (i & 0x40) ? 3 : 1;
+               }
 
                data->alarms =
-                       it87_read_value(client, IT87_REG_ALARM1) |
-                       (it87_read_value(client, IT87_REG_ALARM2) << 8) |
-                       (it87_read_value(client, IT87_REG_ALARM3) << 16);
-               data->fan_main_ctrl = it87_read_value(client, 
IT87_REG_FAN_MAIN_CTRL);
-
-               data->sensor = it87_read_value(client, IT87_REG_TEMP_ENABLE);
-               /* The 8705 does not have VID capability */
-               if (data->type == it8712) {
-                       data->vid = it87_read_value(client, IT87_REG_VID);
-                       data->vid &= 0x1f;
+                       it87_read_value(data, IT87_REG_ALARM1) |
+                       (it87_read_value(data, IT87_REG_ALARM2) << 8) |
+                       (it87_read_value(data, IT87_REG_ALARM3) << 16);
+               data->fan_main_ctrl = it87_read_value(data,
+                               IT87_REG_FAN_MAIN_CTRL);
+               data->fan_ctl = it87_read_value(data, IT87_REG_FAN_CTL);
+
+               data->sensor = it87_read_value(data, IT87_REG_TEMP_ENABLE);
+               /* The 8705 does not have VID capability.
+                  The 8718 and the 8720 don't use IT87_REG_VID for the
+                  same purpose. */
+               if (data->type == it8712 || data->type == it8716) {
+                       data->vid = it87_read_value(data, IT87_REG_VID);
+                       /* The older IT8712F revisions had only 5 VID pins,
+                          but we assume it is always safe to read 6 bits. */
+                       data->vid &= 0x3f;
                }
                data->last_updated = jiffies;
                data->valid = 1;
@@ -1165,20 +1542,71 @@ static struct it87_data *it87_update_dev
        return data;
 }
 
+static int __init it87_device_add(unsigned short address,
+                                 struct it87_sio_data *sio_data)
+{
+       struct resource res = {
+               .start  = address + IT87_EC_OFFSET,
+               .end    = address + IT87_EC_OFFSET + IT87_EC_EXTENT - 1,
+               .name   = DRVNAME,
+               .flags  = IORESOURCE_IO,
+       };
+       int err;
+
+       pdev = platform_device_alloc(DRVNAME, address);
+       if (!pdev) {
+               err = -ENOMEM;
+               printk(KERN_ERR DRVNAME ": Device allocation failed\n");
+               goto exit;
+       }
+
+       err = platform_device_add_resources(pdev, &res, 1);
+       if (err) {
+               printk(KERN_ERR DRVNAME ": Device resource addition failed "
+                      "(%d)\n", err);
+               goto exit_device_put;
+       }
+
+       err = platform_device_add_data(pdev, sio_data,
+                                      sizeof(struct it87_sio_data));
+       if (err) {
+               printk(KERN_ERR DRVNAME ": Platform data allocation failed\n");
+               goto exit_device_put;
+       }
+
+       err = platform_device_add(pdev);
+       if (err) {
+               printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
+                      err);
+               goto exit_device_put;
+       }
+
+       return 0;
+
+exit_device_put:
+       platform_device_put(pdev);
+exit:
+       return err;
+}
+
 static int __init sm_it87_init(void)
 {
-       int res;
-
-       res = i2c_add_driver(&it87_driver);
-       if (res)
-               return res;
-
-       if (!it87_find(&isa_address)) {
-               res = i2c_isa_add_driver(&it87_isa_driver);
-               if (res) {
-                       i2c_del_driver(&it87_driver);
-                       return res;
-               }
+       int err;
+       unsigned short isa_address=0;
+       struct it87_sio_data sio_data;
+
+       memset(&sio_data, 0, sizeof(struct it87_sio_data));
+       err = it87_find(&isa_address, &sio_data);
+       if (err)
+               return err;
+       err = platform_driver_register(&it87_driver);
+       if (err)
+               return err;
+
+       err = it87_device_add(isa_address, &sio_data);
+       if (err){
+               platform_driver_unregister(&it87_driver);
+               return err;
        }
 
        return 0;
@@ -1186,14 +1614,14 @@ static int __init sm_it87_init(void)
 
 static void __exit sm_it87_exit(void)
 {
-       if (isa_address)
-               i2c_isa_del_driver(&it87_isa_driver);
-       i2c_del_driver(&it87_driver);
-}
-
-
-MODULE_AUTHOR("Chris Gauthron <chrisg@xxxxxxxx>");
-MODULE_DESCRIPTION("IT8705F, IT8712F, Sis950 driver");
+       platform_device_unregister(pdev);
+       platform_driver_unregister(&it87_driver);
+}
+
+
+MODULE_AUTHOR("Chris Gauthron, "
+             "Jean Delvare <khali@xxxxxxxxxxxx>");
+MODULE_DESCRIPTION("IT8705F/8712F/8716F/8718F/8720F/8726F, SiS950 driver");
 module_param(update_vbat, bool, 0);
 MODULE_PARM_DESC(update_vbat, "Update vbat if set else return powerup value");
 module_param(fix_pwm_polarity, bool, 0);

_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/xen-devel

<Prev in Thread] Current Thread [Next in Thread>
  • [Xen-devel] [PATCH 5 of 10] New/Updated drivers: ITE IT87xx and compatibles driver backported from Linux Kernel Ver. 2.6.29.2, Daniel Kiper <=