OE tree imported from monotone branch org.openembedded.oz354fam083 at revision 8b12e3...

[familiar-h63xx-build.git] / org.handhelds.familiar / packages / linux / linux-mtx-1-2.4.27 / 17-lmsensors.2.8.8.patch

--- linux-old/drivers/i2c/i2c-ali1535.c Thu Jan  1 00:00:00 1970
+++ linux/drivers/i2c/i2c-ali1535.c     Mon Dec 13 20:18:40 2004
@@ -0,0 +1,601 @@
+/*
+    i2c-ali1535.c - Part of lm_sensors, Linux kernel modules for hardware
+                    monitoring
+    Copyright (c) 2000  Frodo Looijaard <frodol@dds.nl>, 
+                        Philip Edelbrock <phil@netroedge.com>, 
+                        Mark D. Studebaker <mdsxyz123@yahoo.com>,
+                        Dan Eaton <dan.eaton@rocketlogix.com> and 
+                        Stephen Rousset<stephen.rousset@rocketlogix.com> 
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+    This is the driver for the SMB Host controller on
+    Acer Labs Inc. (ALI) M1535 South Bridge.
+
+    The M1535 is a South bridge for portable systems.
+    It is very similar to the M15x3 South bridges also produced
+    by Acer Labs Inc.  Some of the registers within the part
+    have moved and some have been redefined slightly. Additionally,
+    the sequencing of the SMBus transactions has been modified
+    to be more consistent with the sequencing recommended by
+    the manufacturer and observed through testing.  These
+    changes are reflected in this driver and can be identified
+    by comparing this driver to the i2c-ali15x3 driver.
+    For an overview of these chips see http://www.acerlabs.com
+
+    The SMB controller is part of the 7101 device, which is an
+    ACPI-compliant Power Management Unit (PMU).
+
+    The whole 7101 device has to be enabled for the SMB to work.
+    You can't just enable the SMB alone.
+    The SMB and the ACPI have separate I/O spaces.
+    We make sure that the SMB is enabled. We leave the ACPI alone.
+
+    This driver controls the SMB Host only.
+
+    This driver does not use interrupts.
+*/
+
+
+/* Note: we assume there can only be one ALI1535, with one SMBus interface */
+
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/kernel.h>
+#include <linux/stddef.h>
+#include <linux/sched.h>
+#include <linux/ioport.h>
+#include <linux/i2c.h>
+#include <linux/init.h>
+#include <asm/io.h>
+#include <asm/semaphore.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+
+/* ALI1535 SMBus address offsets */
+#define SMBHSTSTS (0 + ali1535_smba)
+#define SMBHSTTYP (1 + ali1535_smba)
+#define SMBHSTPORT (2 + ali1535_smba)
+#define SMBHSTCMD (7 + ali1535_smba)
+#define SMBHSTADD (3 + ali1535_smba)
+#define SMBHSTDAT0 (4 + ali1535_smba)
+#define SMBHSTDAT1 (5 + ali1535_smba)
+#define SMBBLKDAT (6 + ali1535_smba)
+
+/* PCI Address Constants */
+#define SMBCOM    0x004
+#define SMBREV    0x008
+#define SMBCFG    0x0D1
+#define SMBBA     0x0E2
+#define SMBHSTCFG 0x0F0
+#define SMBCLK    0x0F2
+
+/* Other settings */
+#define MAX_TIMEOUT 500                /* times 1/100 sec */
+#define ALI1535_SMB_IOSIZE 32
+
+/* 
+*/
+#define ALI1535_SMB_DEFAULTBASE 0x8040
+
+/* ALI1535 address lock bits */
+#define ALI1535_LOCK   0x06 < dwe >
+
+/* ALI1535 command constants */
+#define ALI1535_QUICK      0x00
+#define ALI1535_BYTE       0x10
+#define ALI1535_BYTE_DATA  0x20
+#define ALI1535_WORD_DATA  0x30
+#define ALI1535_BLOCK_DATA 0x40
+#define ALI1535_I2C_READ   0x60
+
+#define        ALI1535_DEV10B_EN       0x80    /* Enable 10-bit addressing in */
+                                        /*  I2C read                   */
+#define        ALI1535_T_OUT           0x08    /* Time-out Command (write)    */
+#define        ALI1535_A_HIGH_BIT9     0x08    /* Bit 9 of 10-bit address in  */
+                                        /* Alert-Response-Address      */
+                                        /* (read)                      */
+#define        ALI1535_KILL            0x04    /* Kill Command (write)        */
+#define        ALI1535_A_HIGH_BIT8     0x04    /* Bit 8 of 10-bit address in  */
+                                        /*  Alert-Response-Address     */
+                                        /*  (read)                     */
+
+#define        ALI1535_D_HI_MASK       0x03    /* Mask for isolating bits 9-8 */
+                                        /*  of 10-bit address in I2C   */ 
+                                        /*  Read Command               */
+
+/* ALI1535 status register bits */
+#define ALI1535_STS_IDLE       0x04
+#define ALI1535_STS_BUSY       0x08    /* host busy */
+#define ALI1535_STS_DONE       0x10    /* transaction complete */
+#define ALI1535_STS_DEV                0x20    /* device error */
+#define ALI1535_STS_BUSERR     0x40    /* bus error    */
+#define ALI1535_STS_FAIL       0x80    /* failed bus transaction */
+#define ALI1535_STS_ERR                0xE0    /* all the bad error bits */
+
+#define ALI1535_BLOCK_CLR      0x04    /* reset block data index */
+
+/* ALI1535 device address register bits */
+#define        ALI1535_RD_ADDR         0x01    /* Read/Write Bit in Device    */
+                                        /*  Address field              */
+                                        /*  -> Write = 0               */
+                                        /*  -> Read  = 1               */
+#define        ALI1535_SMBIO_EN        0x04    /* SMB I/O Space enable        */
+
+static int ali1535_transaction(void);
+
+static unsigned short ali1535_smba = 0;
+DECLARE_MUTEX(i2c_ali1535_sem);
+
+
+/* Detect whether a ALI1535 can be found, and initialize it, where necessary.
+   Note the differences between kernels with the old PCI BIOS interface and
+   newer kernels with the real PCI interface. In compat.h some things are
+   defined to make the transition easier. */
+int ali1535_setup(struct pci_dev *ALI1535_dev)
+{
+       int error_return = 0;
+       unsigned char temp;
+
+/* Check the following things:
+       - SMB I/O address is initialized
+       - Device is enabled
+       - We can use the addresses
+*/
+
+/* Determine the address of the SMBus area */
+       pci_read_config_word(ALI1535_dev, SMBBA, &ali1535_smba);
+       ali1535_smba &= (0xffff & ~(ALI1535_SMB_IOSIZE - 1));
+       if (ali1535_smba == 0) {
+               printk
+                   ("i2c-ali1535.o: ALI1535_smb region uninitialized - upgrade BIOS?\n");
+               error_return = -ENODEV;
+       }
+
+       if (error_return == -ENODEV)
+               goto END;
+
+       if (check_region(ali1535_smba, ALI1535_SMB_IOSIZE)) {
+               printk
+                   ("i2c-ali1535.o: ALI1535_smb region 0x%x already in use!\n",
+                    ali1535_smba);
+               error_return = -ENODEV;
+       }
+
+       if (error_return == -ENODEV)
+               goto END;
+
+       /* check if whole device is enabled */
+       pci_read_config_byte(ALI1535_dev, SMBCFG, &temp);
+       if ((temp & ALI1535_SMBIO_EN) == 0) {
+               printk
+                   ("i2c-ali1535.o: SMB device not enabled - upgrade BIOS?\n");
+               error_return = -ENODEV;
+               goto END;
+       }
+
+/* Is SMB Host controller enabled? */
+       pci_read_config_byte(ALI1535_dev, SMBHSTCFG, &temp);
+       if ((temp & 1) == 0) {
+               printk
+                   ("i2c-ali1535.o: SMBus controller not enabled - upgrade BIOS?\n");
+               error_return = -ENODEV;
+               goto END;
+       }
+
+/* set SMB clock to 74KHz as recommended in data sheet */
+       pci_write_config_byte(ALI1535_dev, SMBCLK, 0x20);
+
+       /* Everything is happy, let's grab the memory and set things up. */
+       request_region(ali1535_smba, ALI1535_SMB_IOSIZE, "ali1535-smb");
+
+#ifdef DEBUG
+/*
+  The interrupt routing for SMB is set up in register 0x77 in the
+  1533 ISA Bridge device, NOT in the 7101 device.
+  Don't bother with finding the 1533 device and reading the register.
+  if ((....... & 0x0F) == 1)
+     printk("i2c-ali1535.o: ALI1535 using Interrupt 9 for SMBus.\n");
+*/
+       pci_read_config_byte(ALI1535_dev, SMBREV, &temp);
+       printk("i2c-ali1535.o: SMBREV = 0x%X\n", temp);
+       printk("i2c-ali1535.o: ALI1535_smba = 0x%X\n", ali1535_smba);
+#endif                         /* DEBUG */
+
+      END:
+       return error_return;
+}
+
+
+/* Another internally used function */
+int ali1535_transaction(void)
+{
+       int temp;
+       int result = 0;
+       int timeout = 0;
+
+#ifdef DEBUG
+       printk
+           ("i2c-ali1535.o: Transaction (pre): STS=%02x, TYP=%02x, CMD=%02x, ADD=%02x, DAT0=%02x, "
+            "DAT1=%02x\n", inb_p(SMBHSTSTS), inb_p(SMBHSTTYP),
+            inb_p(SMBHSTCMD), inb_p(SMBHSTADD), inb_p(SMBHSTDAT0),
+            inb_p(SMBHSTDAT1));
+#endif
+
+       /* get status */
+       temp = inb_p(SMBHSTSTS);
+
+       /* Make sure the SMBus host is ready to start transmitting */
+       /* Check the busy bit first */
+       if (temp & ALI1535_STS_BUSY) {
+/*
+   If the host controller is still busy, it may have timed out in the previous transaction,
+   resulting in a "SMBus Timeout" printk.
+   I've tried the following to reset a stuck busy bit.
+       1. Reset the controller with an KILL command.
+          (this doesn't seem to clear the controller if an external device is hung)
+       2. Reset the controller and the other SMBus devices with a T_OUT command.
+          (this clears the host busy bit if an external device is hung,
+          but it comes back upon a new access to a device)
+       3. Disable and reenable the controller in SMBHSTCFG
+   Worst case, nothing seems to work except power reset.
+*/
+/* Abort - reset the host controller */
+/*
+#ifdef DEBUG
+    printk("i2c-ali1535.o: Resetting host controller to clear busy condition\n",temp);
+#endif
+    outb_p(ALI1535_KILL, SMBHSTTYP);
+    temp = inb_p(SMBHSTSTS);
+    if (temp & ALI1535_STS_BUSY) {
+*/
+
+/*
+   Try resetting entire SMB bus, including other devices -
+   This may not work either - it clears the BUSY bit but
+   then the BUSY bit may come back on when you try and use the chip again.
+   If that's the case you are stuck.
+*/
+               printk
+                   ("i2c-ali1535.o: Resetting entire SMB Bus to clear busy condition (%02x)\n",
+                    temp);
+               outb_p(ALI1535_T_OUT, SMBHSTTYP);
+               temp = inb_p(SMBHSTSTS);
+       }
+/*
+  }
+*/
+
+       /* now check the error bits and the busy bit */
+       if (temp & (ALI1535_STS_ERR | ALI1535_STS_BUSY)) {
+               /* do a clear-on-write */
+               outb_p(0xFF, SMBHSTSTS);
+               if ((temp = inb_p(SMBHSTSTS)) &
+                   (ALI1535_STS_ERR | ALI1535_STS_BUSY)) {
+                       /* this is probably going to be correctable only by a power reset
+                          as one of the bits now appears to be stuck */
+                       /* This may be a bus or device with electrical problems. */
+                       printk
+                           ("i2c-ali1535.o: SMBus reset failed! (0x%02x) - controller or device on bus is probably hung\n",
+                            temp);
+                       return -1;
+               }
+       } else {
+               /* check and clear done bit */
+               if (temp & ALI1535_STS_DONE) {
+                       outb_p(temp, SMBHSTSTS);
+               }
+       }
+
+       /* start the transaction by writing anything to the start register */
+       outb_p(0xFF, SMBHSTPORT);
+
+       /* We will always wait for a fraction of a second! */
+       timeout = 0;
+       do {
+               i2c_delay(1);
+               temp = inb_p(SMBHSTSTS);
+       } while (((temp & ALI1535_STS_BUSY) && !(temp & ALI1535_STS_IDLE))
+                && (timeout++ < MAX_TIMEOUT));
+
+       /* If the SMBus is still busy, we give up */
+       if (timeout >= MAX_TIMEOUT) {
+               result = -1;
+               printk("i2c-ali1535.o: SMBus Timeout!\n");
+       }
+
+       if (temp & ALI1535_STS_FAIL) {
+               result = -1;
+#ifdef DEBUG
+               printk("i2c-ali1535.o: Error: Failed bus transaction\n");
+#endif
+       }
+
+/*
+  Unfortunately the ALI SMB controller maps "no response" and "bus collision"
+  into a single bit. No reponse is the usual case so don't do a printk.
+  This means that bus collisions go unreported.
+*/
+       if (temp & ALI1535_STS_BUSERR) {
+               result = -1;
+#ifdef DEBUG
+               printk
+                   ("i2c-ali1535.o: Error: no response or bus collision ADD=%02x\n",
+                    inb_p(SMBHSTADD));
+#endif
+       }
+
+/* haven't ever seen this */
+       if (temp & ALI1535_STS_DEV) {
+               result = -1;
+               printk("i2c-ali1535.o: Error: device error\n");
+       }
+
+/* 
+   check to see if the "command complete" indication is set
+ */
+       if (!(temp & ALI1535_STS_DONE)) {
+               result = -1;
+               printk("i2c-ali1535.o: Error: command never completed\n");
+       }
+#ifdef DEBUG
+       printk
+           ("i2c-ali1535.o: Transaction (post): STS=%02x, TYP=%02x, CMD=%02x, ADD=%02x, "
+            "DAT0=%02x, DAT1=%02x\n", inb_p(SMBHSTSTS), inb_p(SMBHSTTYP),
+            inb_p(SMBHSTCMD), inb_p(SMBHSTADD), inb_p(SMBHSTDAT0),
+            inb_p(SMBHSTDAT1));
+#endif
+
+/* 
+    take consequent actions for error conditions
+ */
+        if (!(temp & ALI1535_STS_DONE)) {
+         /* issue "kill" to reset host controller */
+         outb_p(ALI1535_KILL,SMBHSTTYP);
+         outb_p(0xFF,SMBHSTSTS);
+       }         
+       else if (temp & ALI1535_STS_ERR) {
+         /* issue "timeout" to reset all devices on bus */
+         outb_p(ALI1535_T_OUT,SMBHSTTYP);
+         outb_p(0xFF,SMBHSTSTS);
+       }
+        
+       return result;
+}
+
+/* Return -1 on error. */
+s32 ali1535_access(struct i2c_adapter * adap, u16 addr,
+                  unsigned short flags, char read_write, u8 command,
+                  int size, union i2c_smbus_data * data)
+{
+       int i, len;
+       int temp;
+       int timeout;
+       s32 result = 0;
+
+       down(&i2c_ali1535_sem);
+/* make sure SMBus is idle */
+       temp = inb_p(SMBHSTSTS);
+       for (timeout = 0;
+            (timeout < MAX_TIMEOUT) && !(temp & ALI1535_STS_IDLE);
+            timeout++) {
+               i2c_delay(1);
+               temp = inb_p(SMBHSTSTS);
+       }
+       if (timeout >= MAX_TIMEOUT) {
+               printk("i2c-ali1535.o: Idle wait Timeout! STS=0x%02x\n",
+                      temp);
+       }
+
+/* clear status register (clear-on-write) */
+       outb_p(0xFF, SMBHSTSTS);
+
+       switch (size) {
+       case I2C_SMBUS_QUICK:
+               outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
+                      SMBHSTADD);
+               size = ALI1535_QUICK;
+                outb_p(size, SMBHSTTYP);       /* output command */
+                break;
+       case I2C_SMBUS_BYTE:
+               outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
+                      SMBHSTADD);
+               size = ALI1535_BYTE;
+                outb_p(size, SMBHSTTYP);       /* output command */
+               if (read_write == I2C_SMBUS_WRITE)
+                       outb_p(command, SMBHSTCMD);
+               break;
+       case I2C_SMBUS_BYTE_DATA:
+               outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
+                      SMBHSTADD);
+               size = ALI1535_BYTE_DATA;
+                outb_p(size, SMBHSTTYP);       /* output command */
+               outb_p(command, SMBHSTCMD);
+               if (read_write == I2C_SMBUS_WRITE)
+                       outb_p(data->byte, SMBHSTDAT0);
+               break;
+       case I2C_SMBUS_WORD_DATA:
+               outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
+                      SMBHSTADD);
+               size = ALI1535_WORD_DATA;
+                outb_p(size, SMBHSTTYP);       /* output command */
+               outb_p(command, SMBHSTCMD);
+               if (read_write == I2C_SMBUS_WRITE) {
+                       outb_p(data->word & 0xff, SMBHSTDAT0);
+                       outb_p((data->word & 0xff00) >> 8, SMBHSTDAT1);
+               }
+               break;
+       case I2C_SMBUS_BLOCK_DATA:
+               outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
+                      SMBHSTADD);
+               size = ALI1535_BLOCK_DATA;
+                outb_p(size, SMBHSTTYP);       /* output command */
+               outb_p(command, SMBHSTCMD);
+               if (read_write == I2C_SMBUS_WRITE) {
+                       len = data->block[0];
+                       if (len < 0) {
+                               len = 0;
+                               data->block[0] = len;
+                       }
+                       if (len > 32) {
+                               len = 32;
+                               data->block[0] = len;
+                       }
+                       outb_p(len, SMBHSTDAT0);
+                       outb_p(inb_p(SMBHSTTYP) | ALI1535_BLOCK_CLR, SMBHSTTYP);        /* Reset SMBBLKDAT */
+                       for (i = 1; i <= len; i++)
+                               outb_p(data->block[i], SMBBLKDAT);
+               }
+               break;
+       default:
+               printk
+                   (KERN_WARNING "i2c-ali1535.o: Unsupported transaction %d\n", size);
+               result = -1;
+               goto EXIT;
+       }
+
+       if (ali1535_transaction())      /* Error in transaction */
+         {
+               result = -1;
+               goto EXIT;
+          }
+
+       if ((read_write == I2C_SMBUS_WRITE) || (size == ALI1535_QUICK))
+         {
+               result = 0;
+               goto EXIT;
+          }
+
+       switch (size) {
+       case ALI1535_BYTE:      /* Result put in SMBHSTDAT0 */
+               data->byte = inb_p(SMBHSTDAT0);
+               break;
+       case ALI1535_BYTE_DATA:
+               data->byte = inb_p(SMBHSTDAT0);
+               break;
+       case ALI1535_WORD_DATA:
+               data->word = inb_p(SMBHSTDAT0) + (inb_p(SMBHSTDAT1) << 8);
+               break;
+       case ALI1535_BLOCK_DATA:
+               len = inb_p(SMBHSTDAT0);
+               if (len > 32)
+                       len = 32;
+               data->block[0] = len;
+               outb_p(inb_p(SMBHSTTYP) | ALI1535_BLOCK_CLR, SMBHSTTYP);        /* Reset SMBBLKDAT */
+               for (i = 1; i <= data->block[0]; i++) {
+                       data->block[i] = inb_p(SMBBLKDAT);
+#ifdef DEBUG
+                       printk
+                           ("i2c-ali1535.o: Blk: len=%d, i=%d, data=%02x\n",
+                            len, i, data->block[i]);
+#endif /* DEBUG */
+               }
+               break;
+       }
+EXIT:
+       up(&i2c_ali1535_sem);
+       return result;
+}
+
+
+u32 ali1535_func(struct i2c_adapter *adapter)
+{
+       return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
+           I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
+           I2C_FUNC_SMBUS_BLOCK_DATA;
+}
+
+static struct i2c_algorithm smbus_algorithm = {
+       .name           = "Non-i2c SMBus adapter",
+       .id             = I2C_ALGO_SMBUS,
+       .smbus_xfer     = ali1535_access,
+       .functionality  = ali1535_func,
+};
+
+static struct i2c_adapter ali1535_adapter = {
+       .owner          = THIS_MODULE,
+       .name           = "unset",
+       .id             = I2C_ALGO_SMBUS | I2C_HW_SMBUS_ALI1535,
+       .algo           = &smbus_algorithm,
+};
+
+
+static struct pci_device_id ali1535_ids[] __devinitdata = {
+       {
+       .vendor =       PCI_VENDOR_ID_AL,
+       .device =       PCI_DEVICE_ID_AL_M7101,
+       .subvendor =    PCI_ANY_ID,
+       .subdevice =    PCI_ANY_ID,
+       },
+       { 0, }
+};
+
+static int __devinit ali1535_probe(struct pci_dev *dev, const struct pci_device_id *id)
+{
+       if (ali1535_setup(dev)) {
+               printk
+                   ("i2c-ali1535.o: ALI1535 not detected, module not inserted.\n");
+               return -ENODEV;
+       }
+
+       sprintf(ali1535_adapter.name, "SMBus ALI1535 adapter at %04x",
+               ali1535_smba);
+       return i2c_add_adapter(&ali1535_adapter);
+}
+
+static void __devexit ali1535_remove(struct pci_dev *dev)
+{
+       i2c_del_adapter(&ali1535_adapter);
+       release_region(ali1535_smba, ALI1535_SMB_IOSIZE);
+}
+
+
+static struct pci_driver ali1535_driver = {
+       .name           = "ali1535 smbus",
+       .id_table       = ali1535_ids,
+       .probe          = ali1535_probe,
+       .remove         = __devexit_p(ali1535_remove),
+};
+
+static int __init i2c_ali1535_init(void)
+{
+       printk("i2c-ali1535.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       return pci_module_init(&ali1535_driver);
+}
+
+
+static void __exit i2c_ali1535_exit(void)
+{
+       pci_unregister_driver(&ali1535_driver);
+}
+
+#ifdef RLX
+EXPORT_SYMBOL(ali1535_smba);
+EXPORT_SYMBOL(ali1535_access);
+EXPORT_SYMBOL(i2c_ali1535_sem);
+#endif
+
+MODULE_AUTHOR
+    ("Frodo Looijaard <frodol@dds.nl>, Philip Edelbrock <phil@netroedge.com>, "
+     "Mark D. Studebaker <mdsxyz123@yahoo.com> and Dan Eaton <dan.eaton@rocketlogix.com>");
+MODULE_DESCRIPTION("ALI1535 SMBus driver");
+MODULE_LICENSE("GPL");
+
+module_init(i2c_ali1535_init);
+module_exit(i2c_ali1535_exit);
+
--- linux-old/drivers/i2c/i2c-ali15x3.c Thu Jan  1 00:00:00 1970
+++ linux/drivers/i2c/i2c-ali15x3.c     Mon Dec 13 20:18:40 2004
@@ -0,0 +1,533 @@
+/*
+    ali15x3.c - Part of lm_sensors, Linux kernel modules for hardware
+              monitoring
+    Copyright (c) 1999  Frodo Looijaard <frodol@dds.nl> and
+    Philip Edelbrock <phil@netroedge.com> and
+    Mark D. Studebaker <mdsxyz123@yahoo.com>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+    This is the driver for the SMB Host controller on
+    Acer Labs Inc. (ALI) M1541 and M1543C South Bridges.
+
+    The M1543C is a South bridge for desktop systems.
+    The M1533 is a South bridge for portable systems.
+    They are part of the following ALI chipsets:
+       "Aladdin Pro 2": Includes the M1621 Slot 1 North bridge
+       with AGP and 100MHz CPU Front Side bus
+       "Aladdin V": Includes the M1541 Socket 7 North bridge
+       with AGP and 100MHz CPU Front Side bus
+       "Aladdin IV": Includes the M1541 Socket 7 North bridge
+       with host bus up to 83.3 MHz.
+    For an overview of these chips see http://www.acerlabs.com
+
+    The M1533/M1543C devices appear as FOUR separate devices
+    on the PCI bus. An output of lspci will show something similar
+    to the following:
+
+       00:02.0 USB Controller: Acer Laboratories Inc. M5237
+       00:03.0 Bridge: Acer Laboratories Inc. M7101
+       00:07.0 ISA bridge: Acer Laboratories Inc. M1533
+       00:0f.0 IDE interface: Acer Laboratories Inc. M5229
+
+    The SMB controller is part of the 7101 device, which is an
+    ACPI-compliant Power Management Unit (PMU).
+
+    The whole 7101 device has to be enabled for the SMB to work.
+    You can't just enable the SMB alone.
+    The SMB and the ACPI have separate I/O spaces.
+    We make sure that the SMB is enabled. We leave the ACPI alone.
+
+    This driver controls the SMB Host only.
+    The SMB Slave controller on the M15X3 is not enabled.
+
+    This driver does not use interrupts.
+*/
+
+/* Note: we assume there can only be one ALI15X3, with one SMBus interface */
+
+/* #define DEBUG 1 */
+
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/kernel.h>
+#include <linux/stddef.h>
+#include <linux/sched.h>
+#include <linux/ioport.h>
+#include <linux/i2c.h>
+#include <linux/init.h>
+#include <asm/io.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+#include <linux/sensors_compat.h>
+
+/* ALI15X3 SMBus address offsets */
+#define SMBHSTSTS      (0 + ali15x3_smba)
+#define SMBHSTCNT      (1 + ali15x3_smba)
+#define SMBHSTSTART    (2 + ali15x3_smba)
+#define SMBHSTCMD      (7 + ali15x3_smba)
+#define SMBHSTADD      (3 + ali15x3_smba)
+#define SMBHSTDAT0     (4 + ali15x3_smba)
+#define SMBHSTDAT1     (5 + ali15x3_smba)
+#define SMBBLKDAT      (6 + ali15x3_smba)
+
+/* PCI Address Constants */
+#define SMBCOM         0x004
+#define SMBBA          0x014
+#define SMBATPC                0x05B   /* used to unlock xxxBA registers */
+#define SMBHSTCFG      0x0E0
+#define SMBSLVC                0x0E1
+#define SMBCLK         0x0E2
+#define SMBREV         0x008
+
+/* Other settings */
+#define MAX_TIMEOUT            200     /* times 1/100 sec */
+#define ALI15X3_SMB_IOSIZE     32
+
+/* this is what the Award 1004 BIOS sets them to on a ASUS P5A MB.
+   We don't use these here. If the bases aren't set to some value we
+   tell user to upgrade BIOS and we fail.
+*/
+#define ALI15X3_SMB_DEFAULTBASE        0xE800
+
+/* ALI15X3 address lock bits */
+#define ALI15X3_LOCK           0x06
+
+/* ALI15X3 command constants */
+#define ALI15X3_ABORT          0x02
+#define ALI15X3_T_OUT          0x04
+#define ALI15X3_QUICK          0x00
+#define ALI15X3_BYTE           0x10
+#define ALI15X3_BYTE_DATA      0x20
+#define ALI15X3_WORD_DATA      0x30
+#define ALI15X3_BLOCK_DATA     0x40
+#define ALI15X3_BLOCK_CLR      0x80
+
+/* ALI15X3 status register bits */
+#define ALI15X3_STS_IDLE       0x04
+#define ALI15X3_STS_BUSY       0x08
+#define ALI15X3_STS_DONE       0x10
+#define ALI15X3_STS_DEV                0x20    /* device error */
+#define ALI15X3_STS_COLL       0x40    /* collision or no response */
+#define ALI15X3_STS_TERM       0x80    /* terminated by abort */
+#define ALI15X3_STS_ERR                0xE0    /* all the bad error bits */
+
+
+/* If force_addr is set to anything different from 0, we forcibly enable
+   the device at the given address. */
+static int force_addr = 0;
+MODULE_PARM(force_addr, "i");
+MODULE_PARM_DESC(force_addr,
+                "Initialize the base address of the i2c controller");
+
+static unsigned short ali15x3_smba = 0;
+
+static int ali15x3_setup(struct pci_dev *ALI15X3_dev)
+{
+       u16 a;
+       unsigned char temp;
+
+       /* Check the following things:
+               - SMB I/O address is initialized
+               - Device is enabled
+               - We can use the addresses
+       */
+
+       /* Unlock the register.
+          The data sheet says that the address registers are read-only
+          if the lock bits are 1, but in fact the address registers
+          are zero unless you clear the lock bits.
+       */
+       pci_read_config_byte(ALI15X3_dev, SMBATPC, &temp);
+       if (temp & ALI15X3_LOCK) {
+               temp &= ~ALI15X3_LOCK;
+               pci_write_config_byte(ALI15X3_dev, SMBATPC, temp);
+       }
+
+       /* Determine the address of the SMBus area */
+       pci_read_config_word(ALI15X3_dev, SMBBA, &ali15x3_smba);
+       ali15x3_smba &= (0xffff & ~(ALI15X3_SMB_IOSIZE - 1));
+       if (ali15x3_smba == 0 && force_addr == 0) {
+               dev_err(ALI15X3_dev, "ALI15X3_smb region uninitialized "
+                       "- upgrade BIOS or use force_addr=0xaddr\n");
+               return -ENODEV;
+       }
+
+       if(force_addr)
+               ali15x3_smba = force_addr & ~(ALI15X3_SMB_IOSIZE - 1);
+
+       if (!request_region(ali15x3_smba, ALI15X3_SMB_IOSIZE, "ali15x3-smb")) {
+               dev_err(ALI15X3_dev,
+                       "ALI15X3_smb region 0x%x already in use!\n",
+                       ali15x3_smba);
+               return -ENODEV;
+       }
+
+       if(force_addr) {
+               dev_info(ALI15X3_dev, "forcing ISA address 0x%04X\n",
+                       ali15x3_smba);
+               if (PCIBIOS_SUCCESSFUL !=
+                   pci_write_config_word(ALI15X3_dev, SMBBA, ali15x3_smba))
+                       return -ENODEV;
+               if (PCIBIOS_SUCCESSFUL !=
+                   pci_read_config_word(ALI15X3_dev, SMBBA, &a))
+                       return -ENODEV;
+               if ((a & ~(ALI15X3_SMB_IOSIZE - 1)) != ali15x3_smba) {
+                       /* make sure it works */
+                       dev_err(ALI15X3_dev,
+                               "force address failed - not supported?\n");
+                       return -ENODEV;
+               }
+       }
+       /* check if whole device is enabled */
+       pci_read_config_byte(ALI15X3_dev, SMBCOM, &temp);
+       if ((temp & 1) == 0) {
+               dev_info(ALI15X3_dev, "enabling SMBus device\n");
+               pci_write_config_byte(ALI15X3_dev, SMBCOM, temp | 0x01);
+       }
+
+       /* Is SMB Host controller enabled? */
+       pci_read_config_byte(ALI15X3_dev, SMBHSTCFG, &temp);
+       if ((temp & 1) == 0) {
+               dev_info(ALI15X3_dev, "enabling SMBus controller\n");
+               pci_write_config_byte(ALI15X3_dev, SMBHSTCFG, temp | 0x01);
+       }
+
+       /* set SMB clock to 74KHz as recommended in data sheet */
+       pci_write_config_byte(ALI15X3_dev, SMBCLK, 0x20);
+
+       /*
+         The interrupt routing for SMB is set up in register 0x77 in the
+         1533 ISA Bridge device, NOT in the 7101 device.
+         Don't bother with finding the 1533 device and reading the register.
+       if ((....... & 0x0F) == 1)
+               dev_dbg(ALI15X3_dev, "ALI15X3 using Interrupt 9 for SMBus.\n");
+       */
+       pci_read_config_byte(ALI15X3_dev, SMBREV, &temp);
+       dev_dbg(ALI15X3_dev, "SMBREV = 0x%X\n", temp);
+       dev_dbg(ALI15X3_dev, "iALI15X3_smba = 0x%X\n", ali15x3_smba);
+
+       return 0;
+}
+
+/* Another internally used function */
+static int ali15x3_transaction(struct i2c_adapter *adap)
+{
+       int temp;
+       int result = 0;
+       int timeout = 0;
+
+       dev_dbg(adap, "Transaction (pre): STS=%02x, CNT=%02x, CMD=%02x, "
+               "ADD=%02x, DAT0=%02x, DAT1=%02x\n", inb_p(SMBHSTSTS),
+               inb_p(SMBHSTCNT), inb_p(SMBHSTCMD), inb_p(SMBHSTADD),
+               inb_p(SMBHSTDAT0), inb_p(SMBHSTDAT1));
+
+       /* get status */
+       temp = inb_p(SMBHSTSTS);
+
+       /* Make sure the SMBus host is ready to start transmitting */
+       /* Check the busy bit first */
+       if (temp & ALI15X3_STS_BUSY) {
+       /*
+          If the host controller is still busy, it may have timed out in the
+          previous transaction, resulting in a "SMBus Timeout" Dev.
+          I've tried the following to reset a stuck busy bit.
+               1. Reset the controller with an ABORT command.
+                  (this doesn't seem to clear the controller if an external
+                  device is hung)
+               2. Reset the controller and the other SMBus devices with a
+                  T_OUT command.  (this clears the host busy bit if an
+                  external device is hung, but it comes back upon a new access
+                  to a device)
+               3. Disable and reenable the controller in SMBHSTCFG
+          Worst case, nothing seems to work except power reset.
+       */
+       /* Abort - reset the host controller */
+       /*
+          Try resetting entire SMB bus, including other devices -
+          This may not work either - it clears the BUSY bit but
+          then the BUSY bit may come back on when you try and use the chip again.
+          If that's the case you are stuck.
+       */
+               dev_info(adap, "Resetting entire SMB Bus to "
+                       "clear busy condition (%02x)\n", temp);
+               outb_p(ALI15X3_T_OUT, SMBHSTCNT);
+               temp = inb_p(SMBHSTSTS);
+       }
+
+       /* now check the error bits and the busy bit */
+       if (temp & (ALI15X3_STS_ERR | ALI15X3_STS_BUSY)) {
+               /* do a clear-on-write */
+               outb_p(0xFF, SMBHSTSTS);
+               if ((temp = inb_p(SMBHSTSTS)) &
+                   (ALI15X3_STS_ERR | ALI15X3_STS_BUSY)) {
+                       /* this is probably going to be correctable only by a power reset
+                          as one of the bits now appears to be stuck */
+                       /* This may be a bus or device with electrical problems. */
+                       dev_err(adap, "SMBus reset failed! (0x%02x) - "
+                               "controller or device on bus is probably hung\n",
+                               temp);
+                       return -1;
+               }
+       } else {
+               /* check and clear done bit */
+               if (temp & ALI15X3_STS_DONE) {
+                       outb_p(temp, SMBHSTSTS);
+               }
+       }
+
+       /* start the transaction by writing anything to the start register */
+       outb_p(0xFF, SMBHSTSTART);
+
+       /* We will always wait for a fraction of a second! */
+       timeout = 0;
+       do {
+               i2c_delay(1);
+               temp = inb_p(SMBHSTSTS);
+       } while ((!(temp & (ALI15X3_STS_ERR | ALI15X3_STS_DONE)))
+                && (timeout++ < MAX_TIMEOUT));
+
+       /* If the SMBus is still busy, we give up */
+       if (timeout >= MAX_TIMEOUT) {
+               result = -1;
+               dev_err(adap, "SMBus Timeout!\n");
+       }
+
+       if (temp & ALI15X3_STS_TERM) {
+               result = -1;
+               dev_dbg(adap, "Error: Failed bus transaction\n");
+       }
+
+       /*
+         Unfortunately the ALI SMB controller maps "no response" and "bus
+         collision" into a single bit. No reponse is the usual case so don't
+         do a printk.
+         This means that bus collisions go unreported.
+       */
+       if (temp & ALI15X3_STS_COLL) {
+               result = -1;
+               dev_dbg(adap,
+                       "Error: no response or bus collision ADD=%02x\n",
+                       inb_p(SMBHSTADD));
+       }
+
+       /* haven't ever seen this */
+       if (temp & ALI15X3_STS_DEV) {
+               result = -1;
+               dev_err(adap, "Error: device error\n");
+       }
+       dev_dbg(adap, "Transaction (post): STS=%02x, CNT=%02x, CMD=%02x, "
+               "ADD=%02x, DAT0=%02x, DAT1=%02x\n", inb_p(SMBHSTSTS),
+               inb_p(SMBHSTCNT), inb_p(SMBHSTCMD), inb_p(SMBHSTADD),
+               inb_p(SMBHSTDAT0), inb_p(SMBHSTDAT1));
+       return result;
+}
+
+/* Return -1 on error. */
+static s32 ali15x3_access(struct i2c_adapter * adap, u16 addr,
+                  unsigned short flags, char read_write, u8 command,
+                  int size, union i2c_smbus_data * data)
+{
+       int i, len;
+       int temp;
+       int timeout;
+
+       /* clear all the bits (clear-on-write) */
+       outb_p(0xFF, SMBHSTSTS);
+       /* make sure SMBus is idle */
+       temp = inb_p(SMBHSTSTS);
+       for (timeout = 0;
+            (timeout < MAX_TIMEOUT) && !(temp & ALI15X3_STS_IDLE);
+            timeout++) {
+               i2c_delay(1);
+               temp = inb_p(SMBHSTSTS);
+       }
+       if (timeout >= MAX_TIMEOUT) {
+               dev_err(adap, "Idle wait Timeout! STS=0x%02x\n", temp);
+       }
+
+       switch (size) {
+       case I2C_SMBUS_QUICK:
+               outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
+                      SMBHSTADD);
+               size = ALI15X3_QUICK;
+               break;
+       case I2C_SMBUS_BYTE:
+               outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
+                      SMBHSTADD);
+               if (read_write == I2C_SMBUS_WRITE)
+                       outb_p(command, SMBHSTCMD);
+               size = ALI15X3_BYTE;
+               break;
+       case I2C_SMBUS_BYTE_DATA:
+               outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
+                      SMBHSTADD);
+               outb_p(command, SMBHSTCMD);
+               if (read_write == I2C_SMBUS_WRITE)
+                       outb_p(data->byte, SMBHSTDAT0);
+               size = ALI15X3_BYTE_DATA;
+               break;
+       case I2C_SMBUS_WORD_DATA:
+               outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
+                      SMBHSTADD);
+               outb_p(command, SMBHSTCMD);
+               if (read_write == I2C_SMBUS_WRITE) {
+                       outb_p(data->word & 0xff, SMBHSTDAT0);
+                       outb_p((data->word & 0xff00) >> 8, SMBHSTDAT1);
+               }
+               size = ALI15X3_WORD_DATA;
+               break;
+       case I2C_SMBUS_BLOCK_DATA:
+               outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
+                      SMBHSTADD);
+               outb_p(command, SMBHSTCMD);
+               if (read_write == I2C_SMBUS_WRITE) {
+                       len = data->block[0];
+                       if (len < 0) {
+                               len = 0;
+                               data->block[0] = len;
+                       }
+                       if (len > 32) {
+                               len = 32;
+                               data->block[0] = len;
+                       }
+                       outb_p(len, SMBHSTDAT0);
+                       /* Reset SMBBLKDAT */
+                       outb_p(inb_p(SMBHSTCNT) | ALI15X3_BLOCK_CLR, SMBHSTCNT);
+                       for (i = 1; i <= len; i++)
+                               outb_p(data->block[i], SMBBLKDAT);
+               }
+               size = ALI15X3_BLOCK_DATA;
+               break;
+       default:
+               printk
+                   (KERN_WARNING "i2c-ali15x3.o: Unsupported transaction %d\n", size);
+               return -1;
+       }
+
+       outb_p(size, SMBHSTCNT);        /* output command */
+
+       if (ali15x3_transaction(adap))  /* Error in transaction */
+               return -1;
+
+       if ((read_write == I2C_SMBUS_WRITE) || (size == ALI15X3_QUICK))
+               return 0;
+
+
+       switch (size) {
+       case ALI15X3_BYTE:      /* Result put in SMBHSTDAT0 */
+               data->byte = inb_p(SMBHSTDAT0);
+               break;
+       case ALI15X3_BYTE_DATA:
+               data->byte = inb_p(SMBHSTDAT0);
+               break;
+       case ALI15X3_WORD_DATA:
+               data->word = inb_p(SMBHSTDAT0) + (inb_p(SMBHSTDAT1) << 8);
+               break;
+       case ALI15X3_BLOCK_DATA:
+               len = inb_p(SMBHSTDAT0);
+               if (len > 32)
+                       len = 32;
+               data->block[0] = len;
+               /* Reset SMBBLKDAT */
+               outb_p(inb_p(SMBHSTCNT) | ALI15X3_BLOCK_CLR, SMBHSTCNT);
+               for (i = 1; i <= data->block[0]; i++) {
+                       data->block[i] = inb_p(SMBBLKDAT);
+                       dev_dbg(adap, "Blk: len=%d, i=%d, data=%02x\n",
+                               len, i, data->block[i]);
+               }
+               break;
+       }
+       return 0;
+}
+
+static u32 ali15x3_func(struct i2c_adapter *adapter)
+{
+       return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
+           I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
+           I2C_FUNC_SMBUS_BLOCK_DATA;
+}
+
+static struct i2c_algorithm smbus_algorithm = {
+       .name           = "Non-I2C SMBus adapter",
+       .id             = I2C_ALGO_SMBUS,
+       .smbus_xfer     = ali15x3_access,
+       .functionality  = ali15x3_func,
+};
+
+static struct i2c_adapter ali15x3_adapter = {
+       .owner          = THIS_MODULE,
+       .id             = I2C_ALGO_SMBUS | I2C_HW_SMBUS_ALI15X3,
+       .algo           = &smbus_algorithm,
+       .name   = "unset",
+};
+
+static struct pci_device_id ali15x3_ids[] __devinitdata = {
+       {
+       .vendor =       PCI_VENDOR_ID_AL,
+       .device =       PCI_DEVICE_ID_AL_M7101,
+       .subvendor =    PCI_ANY_ID,
+       .subdevice =    PCI_ANY_ID,
+       },
+       { 0, }
+};
+
+static int __devinit ali15x3_probe(struct pci_dev *dev, const struct pci_device_id *id)
+{
+       if (ali15x3_setup(dev)) {
+               dev_err(dev,
+                       "ALI15X3 not detected, module not inserted.\n");
+               return -ENODEV;
+       }
+
+       snprintf(ali15x3_adapter.name, 32,
+               "SMBus ALI15X3 adapter at %04x", ali15x3_smba);
+       return i2c_add_adapter(&ali15x3_adapter);
+}
+
+static void __devexit ali15x3_remove(struct pci_dev *dev)
+{
+       i2c_del_adapter(&ali15x3_adapter);
+       release_region(ali15x3_smba, ALI15X3_SMB_IOSIZE);
+}
+
+static struct pci_driver ali15x3_driver = {
+       .name           = "ali15x3 smbus",
+       .id_table       = ali15x3_ids,
+       .probe          = ali15x3_probe,
+       .remove         = __devexit_p(ali15x3_remove),
+};
+
+static int __init i2c_ali15x3_init(void)
+{
+       printk("i2c-ali15x3.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       return pci_module_init(&ali15x3_driver);
+}
+
+static void __exit i2c_ali15x3_exit(void)
+{
+       pci_unregister_driver(&ali15x3_driver);
+}
+
+MODULE_AUTHOR ("Frodo Looijaard <frodol@dds.nl>, "
+               "Philip Edelbrock <phil@netroedge.com>, "
+               "and Mark D. Studebaker <mdsxyz123@yahoo.com>");
+MODULE_DESCRIPTION("ALI15X3 SMBus driver");
+MODULE_LICENSE("GPL");
+
+module_init(i2c_ali15x3_init);
+module_exit(i2c_ali15x3_exit);
--- linux-old/drivers/i2c/i2c-amd756.c  Thu Jan  1 00:00:00 1970
+++ linux/drivers/i2c/i2c-amd756.c      Mon Dec 13 20:18:41 2004
@@ -0,0 +1,425 @@
+/*
+    amd756.c - Part of lm_sensors, Linux kernel modules for hardware
+              monitoring
+
+    Copyright (c) 1999-2002 Merlin Hughes <merlin@merlin.org>
+
+    Shamelessly ripped from i2c-piix4.c:
+
+    Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl> and
+    Philip Edelbrock <phil@netroedge.com>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+    2002-04-08: Added nForce support. (Csaba Halasz)
+    2002-10-03: Fixed nForce PnP I/O port. (Michael Steil)
+    2002-12-28: Rewritten into something that resembles a Linux driver (hch)
+    2003-11-29: Added back AMD8111 removed by the previous rewrite.
+                (Philip Pokorny)
+    2004-02-15: Don't register driver to avoid driver conflicts.
+                (Daniel Rune Jensen)
+*/
+
+/*
+   Supports AMD756, AMD766, AMD768, AMD8111 and nVidia nForce
+   Note: we assume there can only be one device, with one SMBus interface.
+*/
+
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/kernel.h>
+#include <linux/stddef.h>
+#include <linux/sched.h>
+#include <linux/ioport.h>
+#include <linux/i2c.h>
+#include <linux/init.h>
+#include <asm/io.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+#define DRV_NAME       "i2c-amd756"
+
+/* AMD756 SMBus address offsets */
+#define SMB_ADDR_OFFSET        0xE0
+#define SMB_IOSIZE             16
+#define SMB_GLOBAL_STATUS      (0x0 + amd756_ioport)
+#define SMB_GLOBAL_ENABLE      (0x2 + amd756_ioport)
+#define SMB_HOST_ADDRESS       (0x4 + amd756_ioport)
+#define SMB_HOST_DATA          (0x6 + amd756_ioport)
+#define SMB_HOST_COMMAND       (0x8 + amd756_ioport)
+#define SMB_HOST_BLOCK_DATA    (0x9 + amd756_ioport)
+#define SMB_HAS_DATA           (0xA + amd756_ioport)
+#define SMB_HAS_DEVICE_ADDRESS (0xC + amd756_ioport)
+#define SMB_HAS_HOST_ADDRESS   (0xE + amd756_ioport)
+#define SMB_SNOOP_ADDRESS      (0xF + amd756_ioport)
+
+/* PCI Address Constants */
+
+/* address of I/O space */
+#define SMBBA     0x058                /* mh */
+#define SMBBANFORCE     0x014
+
+/* general configuration */
+#define SMBGCFG   0x041                /* mh */
+
+/* silicon revision code */
+#define SMBREV    0x008
+
+/* Other settings */
+#define MAX_TIMEOUT 500
+
+/* AMD756 constants */
+#define AMD756_QUICK        0x00
+#define AMD756_BYTE         0x01
+#define AMD756_BYTE_DATA    0x02
+#define AMD756_WORD_DATA    0x03
+#define AMD756_PROCESS_CALL 0x04
+#define AMD756_BLOCK_DATA   0x05
+
+
+static unsigned short amd756_ioport = 0;
+
+/* 
+  SMBUS event = I/O 28-29 bit 11
+     see E0 for the status bits and enabled in E2
+     
+*/
+
+#define GS_ABRT_STS (1 << 0)
+#define GS_COL_STS (1 << 1)
+#define GS_PRERR_STS (1 << 2)
+#define GS_HST_STS (1 << 3)
+#define GS_HCYC_STS (1 << 4)
+#define GS_TO_STS (1 << 5)
+#define GS_SMB_STS (1 << 11)
+
+#define GS_CLEAR_STS (GS_ABRT_STS | GS_COL_STS | GS_PRERR_STS | \
+  GS_HCYC_STS | GS_TO_STS )
+
+#define GE_CYC_TYPE_MASK (7)
+#define GE_HOST_STC (1 << 3)
+#define GE_ABORT (1 << 5)
+
+
+static int amd756_transaction(void)
+{
+       int temp;
+       int result = 0;
+       int timeout = 0;
+
+       pr_debug(DRV_NAME
+              ": Transaction (pre): GS=%04x, GE=%04x, ADD=%04x, DAT=%04x\n",
+              inw_p(SMB_GLOBAL_STATUS), inw_p(SMB_GLOBAL_ENABLE),
+              inw_p(SMB_HOST_ADDRESS), inb_p(SMB_HOST_DATA));
+
+       /* Make sure the SMBus host is ready to start transmitting */
+       if ((temp = inw_p(SMB_GLOBAL_STATUS)) & (GS_HST_STS | GS_SMB_STS)) {
+               pr_debug(DRV_NAME ": SMBus busy (%04x). Waiting... \n", temp);
+               do {
+                       i2c_delay(1);
+                       temp = inw_p(SMB_GLOBAL_STATUS);
+               } while ((temp & (GS_HST_STS | GS_SMB_STS)) &&
+                        (timeout++ < MAX_TIMEOUT));
+               /* If the SMBus is still busy, we give up */
+               if (timeout >= MAX_TIMEOUT) {
+                       pr_debug(DRV_NAME ": Busy wait timeout (%04x)\n", temp);
+                       goto abort;
+               }
+               timeout = 0;
+       }
+
+       /* start the transaction by setting the start bit */
+       outw_p(inw(SMB_GLOBAL_ENABLE) | GE_HOST_STC, SMB_GLOBAL_ENABLE);
+
+       /* We will always wait for a fraction of a second! */
+       do {
+               i2c_delay(1);
+               temp = inw_p(SMB_GLOBAL_STATUS);
+       } while ((temp & GS_HST_STS) && (timeout++ < MAX_TIMEOUT));
+
+       /* If the SMBus is still busy, we give up */
+       if (timeout >= MAX_TIMEOUT) {
+               pr_debug(DRV_NAME ": Completion timeout!\n");
+               goto abort;
+       }
+
+       if (temp & GS_PRERR_STS) {
+               result = -1;
+               pr_debug(DRV_NAME ": SMBus Protocol error (no response)!\n");
+       }
+
+       if (temp & GS_COL_STS) {
+               result = -1;
+               printk(KERN_WARNING DRV_NAME ": SMBus collision!\n");
+       }
+
+       if (temp & GS_TO_STS) {
+               result = -1;
+               pr_debug(DRV_NAME ": SMBus protocol timeout!\n");
+       }
+
+       if (temp & GS_HCYC_STS)
+               pr_debug(DRV_NAME ": SMBus protocol success!\n");
+
+       outw_p(GS_CLEAR_STS, SMB_GLOBAL_STATUS);
+
+#ifdef DEBUG
+       if (((temp = inw_p(SMB_GLOBAL_STATUS)) & GS_CLEAR_STS) != 0x00) {
+               pr_debug(DRV_NAME
+                        ": Failed reset at end of transaction (%04x)\n", temp);
+       }
+
+       pr_debug(DRV_NAME
+                ": Transaction (post): GS=%04x, GE=%04x, ADD=%04x, DAT=%04x\n",
+                inw_p(SMB_GLOBAL_STATUS), inw_p(SMB_GLOBAL_ENABLE),
+                inw_p(SMB_HOST_ADDRESS), inb_p(SMB_HOST_DATA));
+#endif
+
+       return result;
+
+ abort:
+       printk(KERN_WARNING DRV_NAME ": Sending abort.\n");
+       outw_p(inw(SMB_GLOBAL_ENABLE) | GE_ABORT, SMB_GLOBAL_ENABLE);
+       i2c_delay(100);
+       outw_p(GS_CLEAR_STS, SMB_GLOBAL_STATUS);
+       return -1;
+}
+
+/* Return -1 on error. */
+
+static s32 amd756_access(struct i2c_adapter * adap, u16 addr,
+                 unsigned short flags, char read_write,
+                 u8 command, int size, union i2c_smbus_data * data)
+{
+       int i, len;
+
+       /** TODO: Should I supporte the 10-bit transfers? */
+       switch (size) {
+       /* TODO: proc call is supported, I'm just not sure what to do here... */
+       case I2C_SMBUS_QUICK:
+               outw_p(((addr & 0x7f) << 1) | (read_write & 0x01),
+                      SMB_HOST_ADDRESS);
+               size = AMD756_QUICK;
+               break;
+       case I2C_SMBUS_BYTE:
+               outw_p(((addr & 0x7f) << 1) | (read_write & 0x01),
+                      SMB_HOST_ADDRESS);
+               if (read_write == I2C_SMBUS_WRITE)
+                       outb_p(command, SMB_HOST_DATA);
+               size = AMD756_BYTE;
+               break;
+       case I2C_SMBUS_BYTE_DATA:
+               outw_p(((addr & 0x7f) << 1) | (read_write & 0x01),
+                      SMB_HOST_ADDRESS);
+               outb_p(command, SMB_HOST_COMMAND);
+               if (read_write == I2C_SMBUS_WRITE)
+                       outw_p(data->byte, SMB_HOST_DATA);
+               size = AMD756_BYTE_DATA;
+               break;
+       case I2C_SMBUS_WORD_DATA:
+               outw_p(((addr & 0x7f) << 1) | (read_write & 0x01),
+                      SMB_HOST_ADDRESS);
+               outb_p(command, SMB_HOST_COMMAND);
+               if (read_write == I2C_SMBUS_WRITE)
+                       outw_p(data->word, SMB_HOST_DATA);      /* TODO: endian???? */
+               size = AMD756_WORD_DATA;
+               break;
+       case I2C_SMBUS_BLOCK_DATA:
+               outw_p(((addr & 0x7f) << 1) | (read_write & 0x01),
+                      SMB_HOST_ADDRESS);
+               outb_p(command, SMB_HOST_COMMAND);
+               if (read_write == I2C_SMBUS_WRITE) {
+                       len = data->block[0];
+                       if (len < 0)
+                               len = 0;
+                       if (len > 32)
+                               len = 32;
+                       outw_p(len, SMB_HOST_DATA);
+                       /* i = inw_p(SMBHSTCNT); Reset SMBBLKDAT */
+                       for (i = 1; i <= len; i++)
+                               outb_p(data->block[i],
+                                      SMB_HOST_BLOCK_DATA);
+               }
+               size = AMD756_BLOCK_DATA;
+               break;
+       default:
+               printk
+                   (KERN_WARNING "i2c-amd756.o: Unsupported transaction %d\n", size);
+               return -1;
+       }
+
+       /* How about enabling interrupts... */
+       outw_p(size & GE_CYC_TYPE_MASK, SMB_GLOBAL_ENABLE);
+
+       if (amd756_transaction())       /* Error in transaction */
+               return -1;
+
+       if ((read_write == I2C_SMBUS_WRITE) || (size == AMD756_QUICK))
+               return 0;
+
+
+       switch (size) {
+       case AMD756_BYTE:
+               data->byte = inw_p(SMB_HOST_DATA);
+               break;
+       case AMD756_BYTE_DATA:
+               data->byte = inw_p(SMB_HOST_DATA);
+               break;
+       case AMD756_WORD_DATA:
+               data->word = inw_p(SMB_HOST_DATA);      /* TODO: endian???? */
+               break;
+       case AMD756_BLOCK_DATA:
+               data->block[0] = inw_p(SMB_HOST_DATA) & 0x3f;
+               if(data->block[0] > 32)
+                       data->block[0] = 32;
+               /* i = inw_p(SMBHSTCNT); Reset SMBBLKDAT */
+               for (i = 1; i <= data->block[0]; i++)
+                       data->block[i] = inb_p(SMB_HOST_BLOCK_DATA);
+               break;
+       }
+
+       return 0;
+}
+
+static u32 amd756_func(struct i2c_adapter *adapter)
+{
+       return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
+           I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
+           I2C_FUNC_SMBUS_BLOCK_DATA | I2C_FUNC_SMBUS_PROC_CALL;
+}
+
+static struct i2c_algorithm smbus_algorithm = {
+       .name           = "Non-I2C SMBus adapter",
+       .id             = I2C_ALGO_SMBUS,
+       .smbus_xfer     = amd756_access,
+       .functionality  = amd756_func,
+};
+
+static struct i2c_adapter amd756_adapter = {
+       .owner          = THIS_MODULE,
+       .name           = "unset",
+       .id             = I2C_ALGO_SMBUS | I2C_HW_SMBUS_AMD756,
+       .algo           = &smbus_algorithm,
+};
+
+enum chiptype { AMD756, AMD766, AMD768, NFORCE, AMD8111 };
+
+static struct pci_device_id amd756_ids[] __devinitdata = {
+       {PCI_VENDOR_ID_AMD, 0x740B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AMD756 },
+       {PCI_VENDOR_ID_AMD, 0x7413, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AMD766 },
+       {PCI_VENDOR_ID_AMD, 0x7443, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AMD768 },
+       {PCI_VENDOR_ID_AMD, 0x746B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AMD8111 },
+       {PCI_VENDOR_ID_NVIDIA, 0x01B4, PCI_ANY_ID, PCI_ANY_ID, 0, 0, NFORCE },
+       { 0, }
+};
+
+static int __devinit amd756_probe(struct pci_dev *pdev,
+                                 const struct pci_device_id *id)
+{
+       int nforce = (id->driver_data == NFORCE);
+       int error;
+       u8 temp;
+       
+       if (amd756_ioport) {
+               printk(KERN_ERR DRV_NAME ": Only one device supported. "
+                      "(you have a strange motherboard, btw..)\n");
+               return -ENODEV;
+       }
+
+       if (nforce) {
+               if (PCI_FUNC(pdev->devfn) != 1)
+                       return -ENODEV;
+
+               pci_read_config_word(pdev, SMBBANFORCE, &amd756_ioport);
+               amd756_ioport &= 0xfffc;
+       } else { /* amd */
+               if (PCI_FUNC(pdev->devfn) != 3)
+                       return -ENODEV;
+
+               pci_read_config_byte(pdev, SMBGCFG, &temp);
+               if ((temp & 128) == 0) {
+                       printk(KERN_ERR DRV_NAME
+                              ": Error: SMBus controller I/O not enabled!\n");
+                       return -ENODEV;
+               }
+
+               /* Determine the address of the SMBus areas */
+               /* Technically it is a dword but... */
+               pci_read_config_word(pdev, SMBBA, &amd756_ioport);
+               amd756_ioport &= 0xff00;
+               amd756_ioport += SMB_ADDR_OFFSET;
+       }
+
+       if (!request_region(amd756_ioport, SMB_IOSIZE, "amd756-smbus")) {
+               printk(KERN_ERR DRV_NAME
+                      ": SMB region 0x%x already in use!\n", amd756_ioport);
+               return -ENODEV;
+       }
+
+#ifdef DEBUG
+       pci_read_config_byte(pdev, SMBREV, &temp);
+       printk(KERN_DEBUG DRV_NAME ": SMBREV = 0x%X\n", temp);
+       printk(KERN_DEBUG DRV_NAME ": AMD756_smba = 0x%X\n", amd756_ioport);
+#endif
+
+       sprintf(amd756_adapter.name,
+               "SMBus AMD756 adapter at %04x", amd756_ioport);
+
+       error = i2c_add_adapter(&amd756_adapter);
+       if (error) {
+               printk(KERN_ERR DRV_NAME
+                      ": Adapter registration failed, module not inserted.\n");
+               goto out_err;
+       }
+
+       return 0;
+
+ out_err:
+       release_region(amd756_ioport, SMB_IOSIZE);
+       return error;
+}
+
+
+static int __init i2c_amd756_init(void)
+{
+       struct pci_dev *dev;
+       const struct pci_device_id *id;
+
+       printk(KERN_INFO "i2c-amd756.o version %s (%s)\n", LM_VERSION, LM_DATE);
+
+       pci_for_each_dev(dev) {
+               id = pci_match_device(amd756_ids, dev);
+               if (id && amd756_probe(dev, id) >= 0)
+                       return 0; 
+       }
+
+       return -ENODEV;
+}
+
+
+static void __exit i2c_amd756_exit(void)
+{
+       i2c_del_adapter(&amd756_adapter);
+       release_region(amd756_ioport, SMB_IOSIZE);
+}
+
+MODULE_AUTHOR("Merlin Hughes <merlin@merlin.org>");
+MODULE_DESCRIPTION("AMD756/766/768/8111 and nVidia nForce SMBus driver");
+MODULE_LICENSE("GPL");
+
+module_init(i2c_amd756_init)
+module_exit(i2c_amd756_exit)
--- linux-old/drivers/i2c/i2c-amd8111.c Thu Jan  1 00:00:00 1970
+++ linux/drivers/i2c/i2c-amd8111.c     Mon Dec 13 20:18:41 2004
@@ -0,0 +1,421 @@
+/*
+ * SMBus 2.0 driver for AMD-8111 IO-Hub.
+ *
+ * Copyright (c) 2002 Vojtech Pavlik
+ *
+ * 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 version 2.
+ */
+
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/kernel.h>
+#include <linux/stddef.h>
+#include <linux/sched.h>
+#include <linux/ioport.h>
+#include <linux/init.h>
+#include <linux/i2c.h>
+#include <linux/delay.h>
+#include <linux/slab.h>
+#include <asm/io.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+#ifndef I2C_HW_SMBUS_AMD8111
+#error Your i2c is too old - i2c-2.7.0 or greater required!
+#endif
+
+/* kernel 2.4.9 needs this */
+#ifndef min_t
+#define min_t(type,x,y) min(type,x,y)
+#endif
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR ("Vojtech Pavlik <vojtech@suse.cz>");
+MODULE_DESCRIPTION("AMD8111 SMBus 2.0 driver");
+
+struct amd_smbus {
+       struct pci_dev *dev;
+       struct i2c_adapter adapter;
+       int base;
+       int size;
+};
+
+/*
+ * AMD PCI control registers definitions.
+ */
+
+#define AMD_PCI_MISC   0x48
+
+#define AMD_PCI_MISC_SCI       0x04    /* deliver SCI */
+#define AMD_PCI_MISC_INT       0x02    /* deliver PCI IRQ */
+#define AMD_PCI_MISC_SPEEDUP   0x01    /* 16x clock speedup */
+
+/*
+ * ACPI 2.0 chapter 13 PCI interface definitions.
+ */
+
+#define AMD_EC_DATA    0x00    /* data register */
+#define AMD_EC_SC      0x04    /* status of controller */
+#define AMD_EC_CMD     0x04    /* command register */
+#define AMD_EC_ICR     0x08    /* interrupt control register */
+
+#define AMD_EC_SC_SMI  0x04    /* smi event pending */
+#define AMD_EC_SC_SCI  0x02    /* sci event pending */
+#define AMD_EC_SC_BURST        0x01    /* burst mode enabled */
+#define AMD_EC_SC_CMD  0x08    /* byte in data reg is command */
+#define AMD_EC_SC_IBF  0x02    /* data ready for embedded controller */
+#define AMD_EC_SC_OBF  0x01    /* data ready for host */
+
+#define AMD_EC_CMD_RD  0x80    /* read EC */
+#define AMD_EC_CMD_WR  0x81    /* write EC */
+#define AMD_EC_CMD_BE  0x82    /* enable burst mode */
+#define AMD_EC_CMD_BD  0x83    /* disable burst mode */
+#define AMD_EC_CMD_QR  0x84    /* query EC */
+
+/*
+ * ACPI 2.0 chapter 13 access of registers of the EC
+ */
+
+unsigned int amd_ec_wait_write(struct amd_smbus *smbus)
+{
+       int timeout = 500;
+
+       while (timeout-- && (inb(smbus->base + AMD_EC_SC) & AMD_EC_SC_IBF))
+               udelay(1);
+
+       if (!timeout) {
+               printk(KERN_WARNING "i2c-amd8111.c: Timeout while waiting for IBF to clear\n");
+               return -1;
+       }
+
+       return 0;
+}
+
+unsigned int amd_ec_wait_read(struct amd_smbus *smbus)
+{
+       int timeout = 500;
+
+       while (timeout-- && (~inb(smbus->base + AMD_EC_SC) & AMD_EC_SC_OBF))
+               udelay(1);
+
+       if (!timeout) {
+               printk(KERN_WARNING "i2c-amd8111.c: Timeout while waiting for OBF to set\n");
+               return -1;
+       }
+
+       return 0;
+}
+
+unsigned int amd_ec_read(struct amd_smbus *smbus, unsigned char address, unsigned char *data)
+{
+       if (amd_ec_wait_write(smbus))
+               return -1;
+       outb(AMD_EC_CMD_RD, smbus->base + AMD_EC_CMD);
+
+       if (amd_ec_wait_write(smbus))
+               return -1;
+       outb(address, smbus->base + AMD_EC_DATA);
+
+       if (amd_ec_wait_read(smbus))
+               return -1;
+       *data = inb(smbus->base + AMD_EC_DATA);
+
+       return 0;
+}
+
+unsigned int amd_ec_write(struct amd_smbus *smbus, unsigned char address, unsigned char data)
+{
+       if (amd_ec_wait_write(smbus))
+               return -1;
+       outb(AMD_EC_CMD_WR, smbus->base + AMD_EC_CMD);
+
+       if (amd_ec_wait_write(smbus))
+               return -1;
+       outb(address, smbus->base + AMD_EC_DATA);
+
+       if (amd_ec_wait_write(smbus))
+               return -1;
+       outb(data, smbus->base + AMD_EC_DATA);
+
+       return 0;
+}
+
+/*
+ * ACPI 2.0 chapter 13 SMBus 2.0 EC register model
+ */
+
+#define AMD_SMB_PRTCL  0x00    /* protocol, PEC */
+#define AMD_SMB_STS    0x01    /* status */
+#define AMD_SMB_ADDR   0x02    /* address */
+#define AMD_SMB_CMD    0x03    /* command */
+#define AMD_SMB_DATA   0x04    /* 32 data registers */
+#define AMD_SMB_BCNT   0x24    /* number of data bytes */
+#define AMD_SMB_ALRM_A 0x25    /* alarm address */
+#define AMD_SMB_ALRM_D 0x26    /* 2 bytes alarm data */
+
+#define AMD_SMB_STS_DONE       0x80
+#define AMD_SMB_STS_ALRM       0x40
+#define AMD_SMB_STS_RES                0x20
+#define AMD_SMB_STS_STATUS     0x1f
+
+#define AMD_SMB_STATUS_OK      0x00
+#define AMD_SMB_STATUS_FAIL    0x07
+#define AMD_SMB_STATUS_DNAK    0x10
+#define AMD_SMB_STATUS_DERR    0x11
+#define AMD_SMB_STATUS_CMD_DENY        0x12
+#define AMD_SMB_STATUS_UNKNOWN 0x13
+#define AMD_SMB_STATUS_ACC_DENY        0x17
+#define AMD_SMB_STATUS_TIMEOUT 0x18
+#define AMD_SMB_STATUS_NOTSUP  0x19
+#define AMD_SMB_STATUS_BUSY    0x1A
+#define AMD_SMB_STATUS_PEC     0x1F
+
+#define AMD_SMB_PRTCL_WRITE            0x00
+#define AMD_SMB_PRTCL_READ             0x01
+#define AMD_SMB_PRTCL_QUICK            0x02
+#define AMD_SMB_PRTCL_BYTE             0x04
+#define AMD_SMB_PRTCL_BYTE_DATA                0x06
+#define AMD_SMB_PRTCL_WORD_DATA                0x08
+#define AMD_SMB_PRTCL_BLOCK_DATA       0x0a
+#define AMD_SMB_PRTCL_PROC_CALL                0x0c
+#define AMD_SMB_PRTCL_BLOCK_PROC_CALL  0x0d
+#define AMD_SMB_PRTCL_I2C_BLOCK_DATA   0x4a
+#define AMD_SMB_PRTCL_PEC              0x80
+
+
+s32 amd8111_access(struct i2c_adapter * adap, u16 addr, unsigned short flags,
+               char read_write, u8 command, int size, union i2c_smbus_data * data)
+{
+       struct amd_smbus *smbus = adap->algo_data;
+       unsigned char protocol, len, pec, temp[2];
+       int i;
+
+       protocol = (read_write == I2C_SMBUS_READ) ? AMD_SMB_PRTCL_READ : AMD_SMB_PRTCL_WRITE;
+       pec = (flags & I2C_CLIENT_PEC) ? AMD_SMB_PRTCL_PEC : 0;
+
+       switch (size) {
+
+               case I2C_SMBUS_QUICK:
+                       protocol |= AMD_SMB_PRTCL_QUICK;
+                       read_write = I2C_SMBUS_WRITE;
+                       break;
+
+               case I2C_SMBUS_BYTE:
+                       if (read_write == I2C_SMBUS_WRITE)
+                               amd_ec_write(smbus, AMD_SMB_CMD, command);
+                       protocol |= AMD_SMB_PRTCL_BYTE;
+                       break;
+
+               case I2C_SMBUS_BYTE_DATA:
+                       amd_ec_write(smbus, AMD_SMB_CMD, command);
+                       if (read_write == I2C_SMBUS_WRITE)
+                               amd_ec_write(smbus, AMD_SMB_DATA, data->byte);
+                       protocol |= AMD_SMB_PRTCL_BYTE_DATA;
+                       break;
+
+               case I2C_SMBUS_WORD_DATA:
+                       amd_ec_write(smbus, AMD_SMB_CMD, command);
+                       if (read_write == I2C_SMBUS_WRITE) {
+                               amd_ec_write(smbus, AMD_SMB_DATA, data->word);
+                               amd_ec_write(smbus, AMD_SMB_DATA + 1, data->word >> 8);
+                       }
+                       protocol |= AMD_SMB_PRTCL_WORD_DATA | pec;
+                       break;
+
+               case I2C_SMBUS_BLOCK_DATA:
+                       amd_ec_write(smbus, AMD_SMB_CMD, command);
+                       if (read_write == I2C_SMBUS_WRITE) {
+                               len = min_t(u8, data->block[0], 32);
+                               amd_ec_write(smbus, AMD_SMB_BCNT, len);
+                               for (i = 0; i < len; i++)
+                                       amd_ec_write(smbus, AMD_SMB_DATA + i, data->block[i + 1]);
+                       }
+                       protocol |= AMD_SMB_PRTCL_BLOCK_DATA | pec;
+                       break;
+
+               case I2C_SMBUS_I2C_BLOCK_DATA:
+                       len = min_t(u8, data->block[0], 32);
+                       amd_ec_write(smbus, AMD_SMB_CMD, command);
+                       amd_ec_write(smbus, AMD_SMB_BCNT, len);
+                       if (read_write == I2C_SMBUS_WRITE)
+                               for (i = 0; i < len; i++)
+                                       amd_ec_write(smbus, AMD_SMB_DATA + i, data->block[i + 1]);
+                       protocol |= AMD_SMB_PRTCL_I2C_BLOCK_DATA;
+                       break;
+
+               case I2C_SMBUS_PROC_CALL:
+                       amd_ec_write(smbus, AMD_SMB_CMD, command);
+                       amd_ec_write(smbus, AMD_SMB_DATA, data->word);
+                       amd_ec_write(smbus, AMD_SMB_DATA + 1, data->word >> 8);
+                       protocol = AMD_SMB_PRTCL_PROC_CALL | pec;
+                       read_write = I2C_SMBUS_READ;
+                       break;
+
+               case I2C_SMBUS_BLOCK_PROC_CALL:
+                       protocol |= pec;
+                       len = min_t(u8, data->block[0], 31);
+                       amd_ec_write(smbus, AMD_SMB_CMD, command);
+                       amd_ec_write(smbus, AMD_SMB_BCNT, len);
+                       for (i = 0; i < len; i++)
+                               amd_ec_write(smbus, AMD_SMB_DATA + i, data->block[i + 1]);
+                       protocol = AMD_SMB_PRTCL_BLOCK_PROC_CALL | pec;
+                       read_write = I2C_SMBUS_READ;
+                       break;
+
+               case I2C_SMBUS_WORD_DATA_PEC:
+               case I2C_SMBUS_BLOCK_DATA_PEC:
+               case I2C_SMBUS_PROC_CALL_PEC:
+               case I2C_SMBUS_BLOCK_PROC_CALL_PEC:
+                       printk(KERN_WARNING "i2c-amd8111.c: Unexpected software PEC transaction %d\n.", size);
+                       return -1;
+
+               default:
+                       printk(KERN_WARNING "i2c-amd8111.c: Unsupported transaction %d\n", size);
+                       return -1;
+       }
+
+       amd_ec_write(smbus, AMD_SMB_ADDR, addr << 1);
+       amd_ec_write(smbus, AMD_SMB_PRTCL, protocol);
+
+       amd_ec_read(smbus, AMD_SMB_STS, temp + 0);
+
+       if (~temp[0] & AMD_SMB_STS_DONE) {
+               udelay(500);
+               amd_ec_read(smbus, AMD_SMB_STS, temp + 0);
+       }
+
+       if (~temp[0] & AMD_SMB_STS_DONE) {
+               i2c_delay(HZ/100);
+               amd_ec_read(smbus, AMD_SMB_STS, temp + 0);
+       }
+
+       if ((~temp[0] & AMD_SMB_STS_DONE) || (temp[0] & AMD_SMB_STS_STATUS))
+               return -1;
+
+       if (read_write == I2C_SMBUS_WRITE)
+               return 0;
+
+       switch (size) {
+
+               case I2C_SMBUS_BYTE:
+               case I2C_SMBUS_BYTE_DATA:
+                       amd_ec_read(smbus, AMD_SMB_DATA, &data->byte);
+                       break;
+
+               case I2C_SMBUS_WORD_DATA:
+               case I2C_SMBUS_PROC_CALL:
+                       amd_ec_read(smbus, AMD_SMB_DATA, temp + 0);
+                       amd_ec_read(smbus, AMD_SMB_DATA + 1, temp + 1);
+                       data->word = (temp[1] << 8) | temp[0];
+                       break;
+
+               case I2C_SMBUS_BLOCK_DATA:
+               case I2C_SMBUS_BLOCK_PROC_CALL:
+                       amd_ec_read(smbus, AMD_SMB_BCNT, &len);
+                       len = min_t(u8, len, 32);
+               case I2C_SMBUS_I2C_BLOCK_DATA:
+                       for (i = 0; i < len; i++)
+                               amd_ec_read(smbus, AMD_SMB_DATA + i, data->block + i + 1);
+                       data->block[0] = len;
+                       break;
+       }
+
+       return 0;
+}
+
+
+u32 amd8111_func(struct i2c_adapter *adapter)
+{
+       return  I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE | I2C_FUNC_SMBUS_BYTE_DATA |
+               I2C_FUNC_SMBUS_WORD_DATA | I2C_FUNC_SMBUS_BLOCK_DATA |
+               I2C_FUNC_SMBUS_PROC_CALL | I2C_FUNC_SMBUS_BLOCK_PROC_CALL |
+               I2C_FUNC_SMBUS_I2C_BLOCK | I2C_FUNC_SMBUS_HWPEC_CALC;
+}
+
+static struct i2c_algorithm smbus_algorithm = {
+       .name = "Non-I2C SMBus 2.0 adapter",
+       .id = I2C_ALGO_SMBUS,
+       .smbus_xfer = amd8111_access,
+       .functionality = amd8111_func,
+};
+
+
+static struct pci_device_id amd8111_ids[] __devinitdata = {
+       { 0x1022, 0x746a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
+       { 0, }
+};
+
+static int __devinit amd8111_probe(struct pci_dev *dev, const struct pci_device_id *id)
+{
+       struct amd_smbus *smbus;
+       int error;
+
+       if (~pci_resource_flags(dev, 0) & IORESOURCE_IO)
+               return -1;
+
+       if (!(smbus = (void*)kmalloc(sizeof(struct amd_smbus), GFP_KERNEL)))
+               return -1;
+       memset(smbus, 0, sizeof(struct amd_smbus));
+
+       pci_set_drvdata(dev, smbus);
+       smbus->dev = dev;
+       smbus->base = pci_resource_start(dev, 0);
+       smbus->size = pci_resource_len(dev, 0);
+
+       if (!request_region(smbus->base, smbus->size, "amd8111 SMBus 2.0")) {
+               kfree(smbus);
+               return -1;
+       }
+
+       smbus->adapter.owner = THIS_MODULE;
+       sprintf(smbus->adapter.name, "SMBus2 AMD8111 adapter at %04x", smbus->base);
+       smbus->adapter.id = I2C_ALGO_SMBUS | I2C_HW_SMBUS_AMD8111;
+       smbus->adapter.algo = &smbus_algorithm;
+       smbus->adapter.algo_data = smbus;
+
+       error = i2c_add_adapter(&smbus->adapter);
+       if (error) {
+               printk(KERN_WARNING "i2c-amd8111.c: Failed to register adapter.\n");
+               release_region(smbus->base, smbus->size);
+               kfree(smbus);
+               return -1;
+       }
+
+       pci_write_config_dword(smbus->dev, AMD_PCI_MISC, 0);
+
+       printk(KERN_INFO "i2c-amd8111.c: AMD8111 SMBus 2.0 adapter at %#x\n", smbus->base);
+       return 0;
+}
+
+
+static void __devexit amd8111_remove(struct pci_dev *dev)
+{
+       struct amd_smbus *smbus = (void*) pci_get_drvdata(dev);
+       i2c_del_adapter(&smbus->adapter);
+       release_region(smbus->base, smbus->size);
+       kfree(smbus);
+}
+
+static struct pci_driver amd8111_driver = {
+       .name           = "amd8111 smbus 2.0",
+       .id_table       = amd8111_ids,
+       .probe          = amd8111_probe,
+       .remove         = __devexit_p(amd8111_remove),
+};
+
+static int __init i2c_amd8111_init(void)
+{
+       printk(KERN_INFO "i2c-amd8111.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       return pci_module_init(&amd8111_driver);
+}
+
+
+static void __exit i2c_amd8111_exit(void)
+{
+       pci_unregister_driver(&amd8111_driver);
+}
+
+module_init(i2c_amd8111_init);
+module_exit(i2c_amd8111_exit);
--- linux-old/drivers/i2c/i2c-hydra.c   Thu Jan  1 00:00:00 1970
+++ linux/drivers/i2c/i2c-hydra.c       Mon Dec 13 20:18:41 2004
@@ -0,0 +1,175 @@
+/*
+    i2c-hydra.c - Part of lm_sensors,  Linux kernel modules
+                  for hardware monitoring
+
+    i2c Support for the Apple `Hydra' Mac I/O
+
+    Copyright (c) 1999 Geert Uytterhoeven <geert@linux-m68k.org>
+
+    Based on i2c Support for Via Technologies 82C586B South Bridge
+    Copyright (c) 1998, 1999 Kyösti Mälkki <kmalkki@cc.hut.fi>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/types.h>
+#include <linux/i2c.h>
+#include <linux/i2c-algo-bit.h>
+#include <linux/init.h>
+#include <asm/io.h>
+#include <asm/system.h>
+#include <asm/param.h> /* for HZ */
+
+MODULE_LICENSE("GPL");
+
+
+#define HYDRA_CACHE_PD 0x00000030
+
+#define HYDRA_CPD_PD0  0x00000001      /* CachePD lines */
+#define HYDRA_CPD_PD1  0x00000002
+#define HYDRA_CPD_PD2  0x00000004
+#define HYDRA_CPD_PD3  0x00000008
+
+#define HYDRA_SCLK     HYDRA_CPD_PD0
+#define HYDRA_SDAT     HYDRA_CPD_PD1
+#define HYDRA_SCLK_OE  0x00000010
+#define HYDRA_SDAT_OE  0x00000020
+
+static unsigned long hydra_base;
+
+static inline void pdregw(u32 val)
+{
+       writel(val, hydra_base + HYDRA_CACHE_PD);
+}
+
+static inline u32 pdregr(void)
+{
+       u32 val = readl(hydra_base + HYDRA_CACHE_PD);
+       return val;
+}
+
+static void bit_hydra_setscl(void *data, int state)
+{
+       u32 val = pdregr();
+       if (state)
+               val &= ~HYDRA_SCLK_OE;
+       else {
+               val &= ~HYDRA_SCLK;
+               val |= HYDRA_SCLK_OE;
+       }
+       pdregw(val);
+       pdregr();       /* flush posted write */
+}
+
+static void bit_hydra_setsda(void *data, int state)
+{
+       u32 val = pdregr();
+       if (state)
+               val &= ~HYDRA_SDAT_OE;
+       else {
+               val &= ~HYDRA_SDAT;
+               val |= HYDRA_SDAT_OE;
+       }
+       pdregw(val);
+       pdregr();       /* flush posted write */
+}
+
+static int bit_hydra_getscl(void *data)
+{
+       return (pdregr() & HYDRA_SCLK) != 0;
+}
+
+static int bit_hydra_getsda(void *data)
+{
+       return (pdregr() & HYDRA_SDAT) != 0;
+}
+
+/* ------------------------------------------------------------------------ */
+
+static struct i2c_algo_bit_data bit_hydra_data = {
+       .setsda         = bit_hydra_setsda,
+       .setscl         = bit_hydra_setscl,
+       .getsda         = bit_hydra_getsda,
+       .getscl         = bit_hydra_getscl,
+       .udelay         = 5,
+       .mdelay         = 5,
+       .timeout        = HZ
+};
+
+static struct i2c_adapter bit_hydra_ops = {
+       .owner          = THIS_MODULE,
+       .name           = "Hydra i2c",
+       .id             = I2C_HW_B_HYDRA,
+       .algo_data              = &bit_hydra_data,
+};
+
+static struct pci_device_id hydra_ids[] __devinitdata = {
+       {
+               .vendor =       PCI_VENDOR_ID_APPLE,
+               .device =       PCI_DEVICE_ID_APPLE_HYDRA,
+               .subvendor =    PCI_ANY_ID,
+               .subdevice =    PCI_ANY_ID,
+       },
+       { 0, }
+};
+
+static int __devinit hydra_probe(struct pci_dev *dev, const struct pci_device_id *id)
+{
+       unsigned int base_addr;
+
+       base_addr = dev->resource[0].start;
+       hydra_base = (unsigned long) ioremap(base_addr, 0x100);
+
+       pdregw(0);              /* clear SCLK_OE and SDAT_OE */
+       return i2c_bit_add_bus(&bit_hydra_ops);
+}
+
+static void __devexit hydra_remove(struct pci_dev *dev)
+{
+       pdregw(0);      /* clear SCLK_OE and SDAT_OE */
+       i2c_bit_del_bus(&bit_hydra_ops);
+       iounmap((void *) hydra_base);
+}
+
+
+static struct pci_driver hydra_driver = {
+       .name           = "hydra smbus",
+       .id_table       = hydra_ids,
+       .probe          = hydra_probe,
+       .remove         = __devexit_p(hydra_remove),
+};
+
+static int __init i2c_hydra_init(void)
+{
+       return pci_module_init(&hydra_driver);
+}
+
+
+static void __exit i2c_hydra_exit(void)
+{
+       pci_unregister_driver(&hydra_driver);
+}
+
+
+
+MODULE_AUTHOR("Geert Uytterhoeven <geert@linux-m68k.org>");
+MODULE_DESCRIPTION("i2c for Apple Hydra Mac I/O");
+
+module_init(i2c_hydra_init);
+module_exit(i2c_hydra_exit);
+
--- linux-old/drivers/i2c/i2c-i801.c    Thu Jan  1 00:00:00 1970
+++ linux/drivers/i2c/i2c-i801.c        Mon Dec 13 20:18:41 2004
@@ -0,0 +1,656 @@
+/*
+    i801.c - Part of lm_sensors, Linux kernel modules for hardware
+              monitoring
+    Copyright (c) 1998 - 2002  Frodo Looijaard <frodol@dds.nl>,
+    Philip Edelbrock <phil@netroedge.com>, and Mark D. Studebaker
+    <mdsxyz123@yahoo.com>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+    SUPPORTED DEVICES  PCI ID
+    82801AA            2413           
+    82801AB            2423           
+    82801BA            2443           
+    82801CA/CAM                2483           
+    82801DB            24C3   (HW PEC supported, 32 byte buffer not supported)
+    82801EB            24D3   (HW PEC supported, 32 byte buffer not supported)
+    6300ESB            25A4   ("")
+    ICH6               266A
+    This driver supports several versions of Intel's I/O Controller Hubs (ICH).
+    For SMBus support, they are similar to the PIIX4 and are part
+    of Intel's '810' and other chipsets.
+    See the doc/busses/i2c-i801 file for details.
+    I2C Block Read and Process Call are not supported.
+*/
+
+/* Note: we assume there can only be one I801, with one SMBus interface */
+
+/* #define DEBUG 1 */
+
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/kernel.h>
+#include <linux/stddef.h>
+#include <linux/sched.h>
+#include <linux/ioport.h>
+#include <linux/init.h>
+#include <linux/i2c.h>
+#include <asm/io.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+#include <linux/sensors_compat.h>
+
+/* 82801DB is undefined before kernel 2.4.19 */
+#ifndef PCI_DEVICE_ID_INTEL_82801DB_3
+#define PCI_DEVICE_ID_INTEL_82801DB_3      0x24c3
+#endif
+
+#ifdef I2C_FUNC_SMBUS_BLOCK_DATA_PEC
+#define HAVE_PEC
+#endif
+
+/* I801 SMBus address offsets */
+#define SMBHSTSTS      (0 + i801_smba)
+#define SMBHSTCNT      (2 + i801_smba)
+#define SMBHSTCMD      (3 + i801_smba)
+#define SMBHSTADD      (4 + i801_smba)
+#define SMBHSTDAT0     (5 + i801_smba)
+#define SMBHSTDAT1     (6 + i801_smba)
+#define SMBBLKDAT      (7 + i801_smba)
+#define SMBPEC         (8 + i801_smba) /* ICH4 only */
+#define SMBAUXSTS      (12 + i801_smba)        /* ICH4 only */
+#define SMBAUXCTL      (13 + i801_smba)        /* ICH4 only */
+
+/* PCI Address Constants */
+#define SMBBA          0x020
+#define SMBHSTCFG      0x040
+#define SMBREV         0x008
+
+/* Host configuration bits for SMBHSTCFG */
+#define SMBHSTCFG_HST_EN       1
+#define SMBHSTCFG_SMB_SMI_EN   2
+#define SMBHSTCFG_I2C_EN       4
+
+/* Other settings */
+#define MAX_TIMEOUT            100
+#define ENABLE_INT9            0       /* set to 0x01 to enable - untested */
+
+/* I801 command constants */
+#define I801_QUICK             0x00
+#define I801_BYTE              0x04
+#define I801_BYTE_DATA         0x08
+#define I801_WORD_DATA         0x0C
+#define I801_PROC_CALL         0x10    /* later chips only, unimplemented */
+#define I801_BLOCK_DATA                0x14
+#define I801_I2C_BLOCK_DATA    0x18    /* unimplemented */
+#define I801_BLOCK_LAST                0x34
+#define I801_I2C_BLOCK_LAST    0x38    /* unimplemented */
+#define I801_START             0x40
+#define I801_PEC_EN            0x80    /* ICH4 only */
+
+/* insmod parameters */
+
+/* If force_addr is set to anything different from 0, we forcibly enable
+   the I801 at the given address. VERY DANGEROUS! */
+static int force_addr = 0;
+MODULE_PARM(force_addr, "i");
+MODULE_PARM_DESC(force_addr,
+                "Forcibly enable the I801 at the given address. "
+                "EXTREMELY DANGEROUS!");
+
+static int i801_transaction(void);
+static int i801_block_transaction(union i2c_smbus_data *data,
+                                 char read_write, int command);
+
+static unsigned short i801_smba;
+static struct pci_dev *I801_dev;
+static int isich4;
+
+static int i801_setup(struct pci_dev *dev)
+{
+       int error_return = 0;
+       unsigned char temp;
+
+       /* Note: we keep on searching until we have found 'function 3' */
+       if(PCI_FUNC(dev->devfn) != 3)
+               return -ENODEV;
+
+       I801_dev = dev;
+       if (dev->device == PCI_DEVICE_ID_INTEL_82801DB_3 ||
+           dev->device == 0x24d3 ||
+           dev->device == 0x25a4)
+               isich4 = 1;
+       else
+               isich4 = 0;
+
+       /* Determine the address of the SMBus areas */
+       if (force_addr) {
+               i801_smba = force_addr & 0xfff0;
+       } else {
+               pci_read_config_word(I801_dev, SMBBA, &i801_smba);
+               i801_smba &= 0xfff0;
+               if(i801_smba == 0) {
+                       dev_err(dev, "SMB base address uninitialized"
+                               "- upgrade BIOS or use force_addr=0xaddr\n");
+                       return -ENODEV;
+               }
+       }
+
+       if (!request_region(i801_smba, (isich4 ? 16 : 8), "i801-smbus")) {
+               dev_err(dev, "I801_smb region 0x%x already in use!\n",
+                       i801_smba);
+               error_return = -EBUSY;
+               goto END;
+       }
+
+       pci_read_config_byte(I801_dev, SMBHSTCFG, &temp);
+       temp &= ~SMBHSTCFG_I2C_EN;      /* SMBus timing */
+       pci_write_config_byte(I801_dev, SMBHSTCFG, temp);
+
+       /* If force_addr is set, we program the new address here. Just to make
+          sure, we disable the device first. */
+       if (force_addr) {
+               pci_write_config_byte(I801_dev, SMBHSTCFG, temp & 0xfe);
+               pci_write_config_word(I801_dev, SMBBA, i801_smba);
+               pci_write_config_byte(I801_dev, SMBHSTCFG, temp | 0x01);
+               dev_warn(dev, "WARNING: I801 SMBus interface set to "
+                       "new address %04x!\n", i801_smba);
+       } else if ((temp & 1) == 0) {
+               pci_write_config_byte(I801_dev, SMBHSTCFG, temp | 1);
+               dev_warn(dev, "enabling SMBus device\n");
+       }
+
+       if (temp & 0x02)
+               dev_dbg(dev, "I801 using Interrupt SMI# for SMBus.\n");
+       else
+               dev_dbg(dev, "I801 using PCI Interrupt for SMBus.\n");
+
+       pci_read_config_byte(I801_dev, SMBREV, &temp);
+       dev_dbg(dev, "SMBREV = 0x%X\n", temp);
+       dev_dbg(dev, "I801_smba = 0x%X\n", i801_smba);
+
+END:
+       return error_return;
+}
+
+
+static int i801_transaction(void)
+{
+       int temp;
+       int result = 0;
+       int timeout = 0;
+
+       dev_dbg(I801_dev, "Transaction (pre): CNT=%02x, CMD=%02x,"
+               "ADD=%02x, DAT0=%02x, DAT1=%02x\n", inb_p(SMBHSTCNT),
+               inb_p(SMBHSTCMD), inb_p(SMBHSTADD), inb_p(SMBHSTDAT0),
+               inb_p(SMBHSTDAT1));
+
+       /* Make sure the SMBus host is ready to start transmitting */
+       /* 0x1f = Failed, Bus_Err, Dev_Err, Intr, Host_Busy */
+       if ((temp = (0x1f & inb_p(SMBHSTSTS))) != 0x00) {
+               dev_dbg(I801_dev, "SMBus busy (%02x). Resetting... \n",
+                       temp);
+               outb_p(temp, SMBHSTSTS);
+               if ((temp = (0x1f & inb_p(SMBHSTSTS))) != 0x00) {
+                       dev_dbg(I801_dev, "Failed! (%02x)\n", temp);
+                       return -1;
+               } else {
+                       dev_dbg(I801_dev, "Successfull!\n");
+               }
+       }
+
+       outb_p(inb(SMBHSTCNT) | I801_START, SMBHSTCNT);
+
+       /* We will always wait for a fraction of a second! */
+       do {
+               i2c_delay(1);
+               temp = inb_p(SMBHSTSTS);
+       } while ((temp & 0x01) && (timeout++ < MAX_TIMEOUT));
+
+       /* If the SMBus is still busy, we give up */
+       if (timeout >= MAX_TIMEOUT) {
+               dev_dbg(I801_dev, "SMBus Timeout!\n");
+               result = -1;
+       }
+
+       if (temp & 0x10) {
+               result = -1;
+               dev_dbg(I801_dev, "Error: Failed bus transaction\n");
+       }
+
+       if (temp & 0x08) {
+               result = -1;
+               dev_err(I801_dev, "Bus collision! SMBus may be locked "
+                       "until next hard reset. (sorry!)\n");
+               /* Clock stops and slave is stuck in mid-transmission */
+       }
+
+       if (temp & 0x04) {
+               result = -1;
+               dev_dbg(I801_dev, "Error: no response!\n");
+       }
+
+       if ((inb_p(SMBHSTSTS) & 0x1f) != 0x00)
+               outb_p(inb(SMBHSTSTS), SMBHSTSTS);
+
+       if ((temp = (0x1f & inb_p(SMBHSTSTS))) != 0x00) {
+               dev_dbg(I801_dev, "Failed reset at end of transaction"
+                       "(%02x)\n", temp);
+       }
+       dev_dbg(I801_dev, "Transaction (post): CNT=%02x, CMD=%02x, "
+               "ADD=%02x, DAT0=%02x, DAT1=%02x\n", inb_p(SMBHSTCNT),
+               inb_p(SMBHSTCMD), inb_p(SMBHSTADD), inb_p(SMBHSTDAT0),
+               inb_p(SMBHSTDAT1));
+       return result;
+}
+
+/* All-inclusive block transaction function */
+static int i801_block_transaction(union i2c_smbus_data *data, char read_write,
+                                 int command)
+{
+       int i, len;
+       int smbcmd;
+       int temp;
+       int result = 0;
+       int timeout;
+       unsigned char hostc, errmask;
+
+       if (command == I2C_SMBUS_I2C_BLOCK_DATA) {
+               if (read_write == I2C_SMBUS_WRITE) {
+                       /* set I2C_EN bit in configuration register */
+                       pci_read_config_byte(I801_dev, SMBHSTCFG, &hostc);
+                       pci_write_config_byte(I801_dev, SMBHSTCFG,
+                                             hostc | SMBHSTCFG_I2C_EN);
+               } else {
+                       dev_err(I801_dev,
+                               "I2C_SMBUS_I2C_BLOCK_READ not DB!\n");
+                       return -1;
+               }
+       }
+
+       if (read_write == I2C_SMBUS_WRITE) {
+               len = data->block[0];
+               if (len < 1)
+                       len = 1;
+               if (len > 32)
+                       len = 32;
+               outb_p(len, SMBHSTDAT0);
+               outb_p(data->block[1], SMBBLKDAT);
+       } else {
+               len = 32;       /* max for reads */
+       }
+
+       if(isich4 && command != I2C_SMBUS_I2C_BLOCK_DATA) {
+               /* set 32 byte buffer */
+       }
+
+       for (i = 1; i <= len; i++) {
+               if (i == len && read_write == I2C_SMBUS_READ)
+                       smbcmd = I801_BLOCK_LAST;
+               else
+                       smbcmd = I801_BLOCK_DATA;
+               outb_p(smbcmd | ENABLE_INT9, SMBHSTCNT);
+
+               dev_dbg(I801_dev, "Block (pre %d): CNT=%02x, CMD=%02x, "
+                       "ADD=%02x, DAT0=%02x, BLKDAT=%02x\n", i,
+                       inb_p(SMBHSTCNT), inb_p(SMBHSTCMD), inb_p(SMBHSTADD),
+                       inb_p(SMBHSTDAT0), inb_p(SMBBLKDAT));
+
+               /* Make sure the SMBus host is ready to start transmitting */
+               temp = inb_p(SMBHSTSTS);
+               if (i == 1) {
+                       /* Erronenous conditions before transaction: 
+                        * Byte_Done, Failed, Bus_Err, Dev_Err, Intr, Host_Busy */
+                       errmask=0x9f; 
+               } else {
+                       /* Erronenous conditions during transaction: 
+                        * Failed, Bus_Err, Dev_Err, Intr */
+                       errmask=0x1e; 
+               }
+               if (temp & errmask) {
+                       dev_dbg(I801_dev, "SMBus busy (%02x). "
+                               "Resetting... \n", temp);
+                       outb_p(temp, SMBHSTSTS);
+                       if (((temp = inb_p(SMBHSTSTS)) & errmask) != 0x00) {
+                               dev_err(I801_dev,
+                                       "Reset failed! (%02x)\n", temp);
+                               result = -1;
+                                goto END;
+                       }
+                       if (i != 1) {
+                               /* if die in middle of block transaction, fail */
+                               result = -1;
+                               goto END;
+                       }
+               }
+
+               if (i == 1)
+                       outb_p(inb(SMBHSTCNT) | I801_START, SMBHSTCNT);
+
+               /* We will always wait for a fraction of a second! */
+               timeout = 0;
+               do {
+                       temp = inb_p(SMBHSTSTS);
+                       i2c_delay(1);
+               }
+                   while ((!(temp & 0x80))
+                          && (timeout++ < MAX_TIMEOUT));
+
+               /* If the SMBus is still busy, we give up */
+               if (timeout >= MAX_TIMEOUT) {
+                       result = -1;
+                       dev_dbg(I801_dev, "SMBus Timeout!\n");
+               }
+
+               if (temp & 0x10) {
+                       result = -1;
+                       dev_dbg(I801_dev,
+                               "Error: Failed bus transaction\n");
+               } else if (temp & 0x08) {
+                       result = -1;
+                       dev_err(I801_dev, "Bus collision!\n");
+               } else if (temp & 0x04) {
+                       result = -1;
+                       dev_dbg(I801_dev, "Error: no response!\n");
+               }
+
+               if (i == 1 && read_write == I2C_SMBUS_READ) {
+                       len = inb_p(SMBHSTDAT0);
+                       if (len < 1)
+                               len = 1;
+                       if (len > 32)
+                               len = 32;
+                       data->block[0] = len;
+               }
+
+               /* Retrieve/store value in SMBBLKDAT */
+               if (read_write == I2C_SMBUS_READ)
+                       data->block[i] = inb_p(SMBBLKDAT);
+               if (read_write == I2C_SMBUS_WRITE && i+1 <= len)
+                       outb_p(data->block[i+1], SMBBLKDAT);
+               if ((temp & 0x9e) != 0x00)
+                       outb_p(temp, SMBHSTSTS);  /* signals SMBBLKDAT ready */
+
+               if ((temp = (0x1e & inb_p(SMBHSTSTS))) != 0x00) {
+                       dev_dbg(I801_dev,
+                               "Bad status (%02x) at end of transaction\n",
+                               temp);
+               }
+               dev_dbg(I801_dev, "Block (post %d): CNT=%02x, CMD=%02x, "
+                       "ADD=%02x, DAT0=%02x, BLKDAT=%02x\n", i,
+                       inb_p(SMBHSTCNT), inb_p(SMBHSTCMD), inb_p(SMBHSTADD),
+                       inb_p(SMBHSTDAT0), inb_p(SMBBLKDAT));
+
+               if (result < 0)
+                       goto END;
+       }
+
+#ifdef HAVE_PEC
+       if(isich4 && command == I2C_SMBUS_BLOCK_DATA_PEC) {
+               /* wait for INTR bit as advised by Intel */
+               timeout = 0;
+               do {
+                       temp = inb_p(SMBHSTSTS);
+                       i2c_delay(1);
+               } while ((!(temp & 0x02))
+                          && (timeout++ < MAX_TIMEOUT));
+
+               if (timeout >= MAX_TIMEOUT) {
+                       dev_dbg(I801_dev, "PEC Timeout!\n");
+               }
+               outb_p(temp, SMBHSTSTS); 
+       }
+#endif
+       result = 0;
+END:
+       if (command == I2C_SMBUS_I2C_BLOCK_DATA) {
+               /* restore saved configuration register value */
+               pci_write_config_byte(I801_dev, SMBHSTCFG, hostc);
+       }
+       return result;
+}
+
+/* Return -1 on error. */
+static s32 i801_access(struct i2c_adapter * adap, u16 addr,
+                      unsigned short flags, char read_write, u8 command,
+                      int size, union i2c_smbus_data * data)
+{
+       int hwpec = 0;
+       int block = 0;
+       int ret, xact = 0;
+
+#ifdef HAVE_PEC
+       if(isich4)
+               hwpec = (flags & I2C_CLIENT_PEC) != 0;
+#endif
+
+       switch (size) {
+       case I2C_SMBUS_QUICK:
+               outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
+                      SMBHSTADD);
+               xact = I801_QUICK;
+               break;
+       case I2C_SMBUS_BYTE:
+               outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
+                      SMBHSTADD);
+               if (read_write == I2C_SMBUS_WRITE)
+                       outb_p(command, SMBHSTCMD);
+               xact = I801_BYTE;
+               break;
+       case I2C_SMBUS_BYTE_DATA:
+               outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
+                      SMBHSTADD);
+               outb_p(command, SMBHSTCMD);
+               if (read_write == I2C_SMBUS_WRITE)
+                       outb_p(data->byte, SMBHSTDAT0);
+               xact = I801_BYTE_DATA;
+               break;
+       case I2C_SMBUS_WORD_DATA:
+               outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
+                      SMBHSTADD);
+               outb_p(command, SMBHSTCMD);
+               if (read_write == I2C_SMBUS_WRITE) {
+                       outb_p(data->word & 0xff, SMBHSTDAT0);
+                       outb_p((data->word & 0xff00) >> 8, SMBHSTDAT1);
+               }
+               xact = I801_WORD_DATA;
+               break;
+       case I2C_SMBUS_BLOCK_DATA:
+       case I2C_SMBUS_I2C_BLOCK_DATA:
+#ifdef HAVE_PEC
+       case I2C_SMBUS_BLOCK_DATA_PEC:
+               if(hwpec && size == I2C_SMBUS_BLOCK_DATA)
+                       size = I2C_SMBUS_BLOCK_DATA_PEC;
+#endif
+               outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
+                      SMBHSTADD);
+               outb_p(command, SMBHSTCMD);
+               block = 1;
+               break;
+       case I2C_SMBUS_PROC_CALL:
+       default:
+               dev_err(I801_dev, "Unsupported transaction %d\n", size);
+               return -1;
+       }
+
+#ifdef HAVE_PEC
+       if(isich4 && hwpec) {
+               if(size != I2C_SMBUS_QUICK &&
+                  size != I2C_SMBUS_I2C_BLOCK_DATA)
+                       outb_p(1, SMBAUXCTL);   /* enable HW PEC */
+       }
+#endif
+       if(block)
+               ret = i801_block_transaction(data, read_write, size);
+       else {
+               outb_p(xact | ENABLE_INT9, SMBHSTCNT);
+               ret = i801_transaction();
+       }
+
+#ifdef HAVE_PEC
+       if(isich4 && hwpec) {
+               if(size != I2C_SMBUS_QUICK &&
+                  size != I2C_SMBUS_I2C_BLOCK_DATA)
+                       outb_p(0, SMBAUXCTL);
+       }
+#endif
+
+       if(block)
+               return ret;
+       if(ret)
+               return -1;
+       if ((read_write == I2C_SMBUS_WRITE) || (xact == I801_QUICK))
+               return 0;
+
+       switch (xact & 0x7f) {
+       case I801_BYTE: /* Result put in SMBHSTDAT0 */
+       case I801_BYTE_DATA:
+               data->byte = inb_p(SMBHSTDAT0);
+               break;
+       case I801_WORD_DATA:
+               data->word = inb_p(SMBHSTDAT0) + (inb_p(SMBHSTDAT1) << 8);
+               break;
+       }
+       return 0;
+}
+
+
+static u32 i801_func(struct i2c_adapter *adapter)
+{
+       return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
+           I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
+           I2C_FUNC_SMBUS_BLOCK_DATA | I2C_FUNC_SMBUS_WRITE_I2C_BLOCK
+#ifdef HAVE_PEC
+            | (isich4 ? I2C_FUNC_SMBUS_BLOCK_DATA_PEC |
+                        I2C_FUNC_SMBUS_HWPEC_CALC
+                      : 0)
+#endif
+           ;
+}
+
+static struct i2c_algorithm smbus_algorithm = {
+       .name           = "Non-I2C SMBus adapter",
+       .id             = I2C_ALGO_SMBUS,
+       .smbus_xfer     = i801_access,
+       .functionality  = i801_func,
+};
+
+static struct i2c_adapter i801_adapter = {
+       .owner          = THIS_MODULE,
+       .id             = I2C_ALGO_SMBUS | I2C_HW_SMBUS_I801,
+       .algo           = &smbus_algorithm,
+       .name   = "unset",
+};
+
+static struct pci_device_id i801_ids[] __devinitdata = {
+       {
+               .vendor =       PCI_VENDOR_ID_INTEL,
+               .device =       PCI_DEVICE_ID_INTEL_82801AA_3,
+               .subvendor =    PCI_ANY_ID,
+               .subdevice =    PCI_ANY_ID,
+       },
+       {
+               .vendor =       PCI_VENDOR_ID_INTEL,
+               .device =       PCI_DEVICE_ID_INTEL_82801AB_3,
+               .subvendor =    PCI_ANY_ID,
+               .subdevice =    PCI_ANY_ID,
+       },
+       {
+               .vendor =       PCI_VENDOR_ID_INTEL,
+               .device =       PCI_DEVICE_ID_INTEL_82801BA_2,
+               .subvendor =    PCI_ANY_ID,
+               .subdevice =    PCI_ANY_ID,
+       },
+       {
+               .vendor =       PCI_VENDOR_ID_INTEL,
+               .device =       PCI_DEVICE_ID_INTEL_82801CA_3,
+               .subvendor =    PCI_ANY_ID,
+               .subdevice =    PCI_ANY_ID,
+       },
+       {
+               .vendor =       PCI_VENDOR_ID_INTEL,
+               .device =       PCI_DEVICE_ID_INTEL_82801DB_3,
+               .subvendor =    PCI_ANY_ID,
+               .subdevice =    PCI_ANY_ID,
+       },
+       {
+               .vendor =       PCI_VENDOR_ID_INTEL,
+               .device =       0x24d3, /* 82801EB ICH5 */
+               .subvendor =    PCI_ANY_ID,
+               .subdevice =    PCI_ANY_ID,
+       },
+       {
+               .vendor =       PCI_VENDOR_ID_INTEL,
+               .device =       0x25a4, /* PCI_DEVICE_ID_INTEL_ESB_4 */
+               .subvendor =    PCI_ANY_ID,
+               .subdevice =    PCI_ANY_ID,
+       },
+       {
+               .vendor =       PCI_VENDOR_ID_INTEL,
+               .device =       0x266a, /* PCI_DEVICE_ID_INTEL_ICH6_16 */
+               .subvendor =    PCI_ANY_ID,
+               .subdevice =    PCI_ANY_ID,
+       },
+       { 0, }
+};
+
+static int __devinit i801_probe(struct pci_dev *dev, const struct pci_device_id *id)
+{
+
+       if (i801_setup(dev)) {
+               dev_warn(dev,
+                       "I801 not detected, module not inserted.\n");
+               return -ENODEV;
+       }
+
+       snprintf(i801_adapter.name, 32,
+               "SMBus I801 adapter at %04x", i801_smba);
+       return i2c_add_adapter(&i801_adapter);
+}
+
+static void __devexit i801_remove(struct pci_dev *dev)
+{
+       i2c_del_adapter(&i801_adapter);
+       release_region(i801_smba, (isich4 ? 16 : 8));
+}
+
+static struct pci_driver i801_driver = {
+       .name           = "i801 smbus",
+       .id_table       = i801_ids,
+       .probe          = i801_probe,
+       .remove         = __devexit_p(i801_remove),
+};
+
+static int __init i2c_i801_init(void)
+{
+       printk(KERN_INFO "i2c-i801 version %s (%s)\n", LM_VERSION, LM_DATE);
+       return pci_module_init(&i801_driver);
+}
+
+static void __exit i2c_i801_exit(void)
+{
+       pci_unregister_driver(&i801_driver);
+}
+
+MODULE_AUTHOR ("Frodo Looijaard <frodol@dds.nl>, "
+               "Philip Edelbrock <phil@netroedge.com>, "
+               "and Mark D. Studebaker <mdsxyz123@yahoo.com>");
+MODULE_DESCRIPTION("I801 SMBus driver");
+MODULE_LICENSE("GPL");
+
+module_init(i2c_i801_init);
+module_exit(i2c_i801_exit);
--- linux-old/drivers/i2c/i2c-i810.c    Thu Jan  1 00:00:00 1970
+++ linux/drivers/i2c/i2c-i810.c        Mon Dec 13 20:18:41 2004
@@ -0,0 +1,310 @@
+/*
+    i2c-i810.c - Part of lm_sensors, Linux kernel modules for hardware
+              monitoring
+    Copyright (c) 1998, 1999, 2000  Frodo Looijaard <frodol@dds.nl>,
+    Philip Edelbrock <phil@netroedge.com>,
+    Ralph Metzler <rjkm@thp.uni-koeln.de>, and
+    Mark D. Studebaker <mdsxyz123@yahoo.com>
+    
+    Based on code written by Ralph Metzler <rjkm@thp.uni-koeln.de> and
+    Simon Vogl
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+/*
+   This interfaces to the I810/I815 to provide access to
+   the DDC Bus and the I2C Bus.
+
+   SUPPORTED DEVICES   PCI ID
+   i810AA              7121           
+   i810AB              7123           
+   i810E               7125           
+   i815                        1132           
+*/
+
+
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/i2c.h>
+#include <linux/i2c-algo-bit.h>
+#include <linux/init.h>
+#include <asm/io.h>
+#include <asm/param.h> /* for HZ */
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+MODULE_LICENSE("GPL");
+
+#ifndef PCI_DEVICE_ID_INTEL_82815_2
+#define PCI_DEVICE_ID_INTEL_82815_2   0x1132
+#endif
+
+/* GPIO register locations */
+#define I810_IOCONTROL_OFFSET 0x5000
+#define I810_HVSYNC    0x00    /* not used */
+#define I810_GPIOA     0x10
+#define I810_GPIOB     0x14
+
+/* bit locations in the registers */
+#define SCL_DIR_MASK   0x0001
+#define SCL_DIR                0x0002
+#define SCL_VAL_MASK   0x0004
+#define SCL_VAL_OUT    0x0008
+#define SCL_VAL_IN     0x0010
+#define SDA_DIR_MASK   0x0100
+#define SDA_DIR                0x0200
+#define SDA_VAL_MASK   0x0400
+#define SDA_VAL_OUT    0x0800
+#define SDA_VAL_IN     0x1000
+
+/* initialization states */
+#define INIT1  0x1
+#define INIT2  0x2
+#define INIT3  0x4
+
+/* delays */
+#define CYCLE_DELAY            10
+#define TIMEOUT                        (HZ / 2)
+
+
+static void config_i810(struct pci_dev *dev);
+
+
+static unsigned long ioaddr;
+
+/* The i810 GPIO registers have individual masks for each bit
+   so we never have to read before writing. Nice. */
+
+static void bit_i810i2c_setscl(void *data, int val)
+{
+       writel((val ? SCL_VAL_OUT : 0) | SCL_DIR | SCL_DIR_MASK | SCL_VAL_MASK,
+            ioaddr + I810_GPIOB);
+       readl(ioaddr + I810_GPIOB);     /* flush posted write */
+}
+
+static void bit_i810i2c_setsda(void *data, int val)
+{
+       writel((val ? SDA_VAL_OUT : 0) | SDA_DIR | SDA_DIR_MASK | SDA_VAL_MASK,
+            ioaddr + I810_GPIOB);
+       readl(ioaddr + I810_GPIOB);     /* flush posted write */
+}
+
+/* The GPIO pins are open drain, so the pins could always remain outputs.
+   However, some chip versions don't latch the inputs unless they
+   are set as inputs.
+   We rely on the i2c-algo-bit routines to set the pins high before
+   reading the input from other chips. Following guidance in the 815
+   prog. ref. guide, we do a "dummy write" of 0 to the register before
+   reading which forces the input value to be latched. We presume this
+   applies to the 810 as well; shouldn't hurt anyway. This is necessary to get
+   i2c_algo_bit bit_test=1 to pass. */
+
+static int bit_i810i2c_getscl(void *data)
+{
+       writel(SCL_DIR_MASK, ioaddr + I810_GPIOB);
+       writel(0, ioaddr + I810_GPIOB);
+       return (0 != (readl(ioaddr + I810_GPIOB) & SCL_VAL_IN));
+}
+
+static int bit_i810i2c_getsda(void *data)
+{
+       writel(SDA_DIR_MASK, ioaddr + I810_GPIOB);
+       writel(0, ioaddr + I810_GPIOB);
+       return (0 != (readl(ioaddr + I810_GPIOB) & SDA_VAL_IN));
+}
+
+static void bit_i810ddc_setscl(void *data, int val)
+{
+       writel((val ? SCL_VAL_OUT : 0) | SCL_DIR | SCL_DIR_MASK | SCL_VAL_MASK,
+            ioaddr + I810_GPIOA);
+       readl(ioaddr + I810_GPIOA);     /* flush posted write */
+}
+
+static void bit_i810ddc_setsda(void *data, int val)
+{
+       writel((val ? SDA_VAL_OUT : 0) | SDA_DIR | SDA_DIR_MASK | SDA_VAL_MASK,
+            ioaddr + I810_GPIOA);
+       readl(ioaddr + I810_GPIOA);     /* flush posted write */
+}
+
+static int bit_i810ddc_getscl(void *data)
+{
+       writel(SCL_DIR_MASK, ioaddr + I810_GPIOA);
+       writel(0, ioaddr + I810_GPIOA);
+       return (0 != (readl(ioaddr + I810_GPIOA) & SCL_VAL_IN));
+}
+
+static int bit_i810ddc_getsda(void *data)
+{
+       writel(SDA_DIR_MASK, ioaddr + I810_GPIOA);
+       writel(0, ioaddr + I810_GPIOA);
+       return (0 != (readl(ioaddr + I810_GPIOA) & SDA_VAL_IN));
+}
+
+
+/* Configures the chip */
+void config_i810(struct pci_dev *dev)
+{
+       unsigned long cadr;
+
+       /* map I810 memory */
+       cadr = dev->resource[1].start;
+       cadr += I810_IOCONTROL_OFFSET;
+       cadr &= PCI_BASE_ADDRESS_MEM_MASK;
+       ioaddr = (unsigned long)ioremap_nocache(cadr, 0x1000);
+       if(ioaddr) {
+               bit_i810i2c_setscl(NULL, 1);
+               bit_i810i2c_setsda(NULL, 1);
+               bit_i810ddc_setscl(NULL, 1);
+               bit_i810ddc_setsda(NULL, 1);
+       }
+}
+
+
+static struct i2c_algo_bit_data i810_i2c_bit_data = {
+       .setsda         = bit_i810i2c_setsda,
+       .setscl         = bit_i810i2c_setscl,
+       .getsda         = bit_i810i2c_getsda,
+       .getscl         = bit_i810i2c_getscl,
+       .udelay         = CYCLE_DELAY,
+       .mdelay         = CYCLE_DELAY,
+       .timeout        = TIMEOUT,
+};
+
+static struct i2c_adapter i810_i2c_adapter = {
+       .owner          = THIS_MODULE,
+       .name           = "I810/I815 I2C Adapter",
+       .id             = I2C_HW_B_I810,
+       .algo_data      = &i810_i2c_bit_data,
+};
+
+static struct i2c_algo_bit_data i810_ddc_bit_data = {
+       .setsda         = bit_i810ddc_setsda,
+       .setscl         = bit_i810ddc_setscl,
+       .getsda         = bit_i810ddc_getsda,
+       .getscl         = bit_i810ddc_getscl,
+       .udelay         = CYCLE_DELAY,
+       .mdelay         = CYCLE_DELAY,
+       .timeout        = TIMEOUT,
+};
+
+static struct i2c_adapter i810_ddc_adapter = {
+       .owner          = THIS_MODULE,
+       .name           = "I810/I815 DDC Adapter",
+       .id             = I2C_HW_B_I810,
+       .algo_data      = &i810_ddc_bit_data,
+};
+
+
+static struct pci_device_id i810_ids[] __devinitdata = {
+       {
+               .vendor =       PCI_VENDOR_ID_INTEL,
+               .device =       PCI_DEVICE_ID_INTEL_82810_IG1,
+               .subvendor =    PCI_ANY_ID,
+               .subdevice =    PCI_ANY_ID,
+       },
+       {
+               .vendor =       PCI_VENDOR_ID_INTEL,
+               .device =       PCI_DEVICE_ID_INTEL_82810_IG3,
+               .subvendor =    PCI_ANY_ID,
+               .subdevice =    PCI_ANY_ID,
+       },
+       {
+               .vendor =       PCI_VENDOR_ID_INTEL,
+               .device =       0x7125,
+               .subvendor =    PCI_ANY_ID,
+               .subdevice =    PCI_ANY_ID,
+       },
+       {
+               .vendor =       PCI_VENDOR_ID_INTEL,
+               .device =       PCI_DEVICE_ID_INTEL_82815_2,
+               .subvendor =    PCI_ANY_ID,
+               .subdevice =    PCI_ANY_ID,
+       },
+       {
+               .vendor =       PCI_VENDOR_ID_INTEL,
+               .device =       0x2562,
+               .subvendor =    PCI_ANY_ID,
+               .subdevice =    PCI_ANY_ID,
+       },
+       { 0, }
+};
+
+static int __devinit i810_probe(struct pci_dev *dev, const struct pci_device_id *id)
+{
+       int retval;
+
+       config_i810(dev);
+       printk("i2c-i810.o: i810/i815 found.\n");
+
+       retval = i2c_bit_add_bus(&i810_i2c_adapter);
+       if(retval)
+               return retval;
+       retval = i2c_bit_add_bus(&i810_ddc_adapter);
+       if(retval)
+               i2c_bit_del_bus(&i810_i2c_adapter);
+       return retval;
+}
+
+static void __devexit i810_remove(struct pci_dev *dev)
+{
+       i2c_bit_del_bus(&i810_ddc_adapter);
+       i2c_bit_del_bus(&i810_i2c_adapter);
+}
+
+
+/* Don't register driver to avoid driver conflicts */
+/*
+static struct pci_driver i810_driver = {
+       .name           = "i810 smbus",
+       .id_table       = i810_ids,
+       .probe          = i810_probe,
+       .remove         = __devexit_p(i810_remove),
+};
+*/
+
+static int __init i2c_i810_init(void)
+{
+       struct pci_dev *dev;
+       const struct pci_device_id *id;
+
+       printk("i2c-i810.o version %s (%s)\n", LM_VERSION, LM_DATE);
+/*
+       return pci_module_init(&i810_driver);
+*/
+       pci_for_each_dev(dev) {
+               id = pci_match_device(i810_ids, dev);
+               if(id)
+                       if(i810_probe(dev, id) >= 0)
+                               return 0;
+       }
+       return -ENODEV;
+}
+
+static void __exit i2c_i810_exit(void)
+{
+/*
+       pci_unregister_driver(&i810_driver);
+*/
+       i810_remove(NULL);
+       iounmap((void *)ioaddr);
+}
+
+MODULE_AUTHOR
+    ("Frodo Looijaard <frodol@dds.nl>, Philip Edelbrock <phil@netroedge.com>, Ralph Metzler <rjkm@thp.uni-koeln.de>, and Mark D. Studebaker <mdsxyz123@yahoo.com>");
+MODULE_DESCRIPTION("I810/I815 I2C/DDC driver");
+
+module_init(i2c_i810_init);
+module_exit(i2c_i810_exit);
--- linux-old/drivers/i2c/i2c-isa.c     Thu Jan  1 00:00:00 1970
+++ linux/drivers/i2c/i2c-isa.c Mon Dec 13 20:18:41 2004
@@ -0,0 +1,74 @@
+/*
+    i2c-isa.c - Part of lm_sensors, Linux kernel modules for hardware
+            monitoring
+    Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl> 
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/* This implements an i2c algorithm/adapter for ISA bus. Not that this is
+   on first sight very useful; almost no functionality is preserved.
+   Except that it makes writing drivers for chips which can be on both
+   the SMBus and the ISA bus very much easier. See lm78.c for an example
+   of this. */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/i2c.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+static u32 isa_func(struct i2c_adapter *adapter);
+
+/* This is the actual algorithm we define */
+static struct i2c_algorithm isa_algorithm = {
+       .name           = "ISA bus algorithm",
+       .id             = I2C_ALGO_ISA,
+       .functionality  = isa_func,
+};
+
+/* There can only be one... */
+static struct i2c_adapter isa_adapter = {
+       .owner          = THIS_MODULE,
+       .name           = "ISA main adapter",
+       .id             = I2C_ALGO_ISA | I2C_HW_ISA,
+       .algo           = &isa_algorithm,
+};
+
+/* We can't do a thing... */
+static u32 isa_func(struct i2c_adapter *adapter)
+{
+       return 0;
+}
+
+static int __init i2c_isa_init(void)
+{
+       printk("i2c-isa.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       return i2c_add_adapter(&isa_adapter);
+}
+
+static void __exit i2c_isa_exit(void)
+{
+       i2c_del_adapter(&isa_adapter);
+}
+
+MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
+MODULE_DESCRIPTION("ISA bus access through i2c");
+MODULE_LICENSE("GPL");
+
+module_init(i2c_isa_init);
+module_exit(i2c_isa_exit);
--- linux-old/drivers/i2c/i2c-nforce2.c Thu Jan  1 00:00:00 1970
+++ linux/drivers/i2c/i2c-nforce2.c     Mon Dec 13 20:18:41 2004
@@ -0,0 +1,409 @@
+/*
+    SMBus driver for nVidia nForce2 MCP
+
+    Copyright (c) 2003  Hans-Frieder Vogt <hfvogt@arcor.de>,
+    Based on
+    SMBus 2.0 driver for AMD-8111 IO-Hub
+    Copyright (c) 2002 Vojtech Pavlik
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+    SUPPORTED DEVICES  PCI ID
+    nForce2 MCP                0064       
+
+    This driver supports the 2 SMBuses that are included in the MCP2 of the
+    nForce2 chipset.
+*/
+
+/* Note: we assume there can only be one nForce2, with two SMBus interfaces */
+
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/kernel.h>
+#include <linux/stddef.h>
+#include <linux/sched.h>
+#include <linux/ioport.h>
+#include <linux/init.h>
+#include <linux/i2c.h>
+#include <linux/delay.h>
+#include <linux/slab.h>
+#include <asm/io.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+/* kernel 2.4.9 needs this */
+#ifndef min_t
+#define min_t(type,x,y) min(type,x,y)
+#endif
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR ("Hans-Frieder Vogt <hfvogt@arcor.de>");
+MODULE_DESCRIPTION("nForce2 SMBus driver");
+
+#ifndef PCI_DEVICE_ID_NVIDIA_NFORCE2_SMBUS
+#define PCI_DEVICE_ID_NVIDIA_NFORCE2_SMBUS   0x0064
+#endif
+
+
+struct nforce2_smbus {
+       struct pci_dev *dev;
+       struct i2c_adapter adapter;
+       int base;
+       int size;
+};
+
+
+/*
+ * nVidia nForce2 SMBus control register definitions
+ */
+#define NFORCE_PCI_SMB1        0x50
+#define NFORCE_PCI_SMB2        0x54
+
+
+/*
+ * ACPI 2.0 chapter 13 SMBus 2.0 EC register model
+ */
+#define NVIDIA_SMB_PRTCL       (smbus->base + 0x00)    /* protocol, PEC */
+#define NVIDIA_SMB_STS         (smbus->base + 0x01)    /* status */
+#define NVIDIA_SMB_ADDR                (smbus->base + 0x02)    /* address */
+#define NVIDIA_SMB_CMD         (smbus->base + 0x03)    /* command */
+#define NVIDIA_SMB_DATA                (smbus->base + 0x04)    /* 32 data registers */
+#define NVIDIA_SMB_BCNT                (smbus->base + 0x24)    /* number of data bytes */
+#define NVIDIA_SMB_ALRM_A      (smbus->base + 0x25)    /* alarm address */
+#define NVIDIA_SMB_ALRM_D      (smbus->base + 0x26)    /* 2 bytes alarm data */
+
+#define NVIDIA_SMB_STS_DONE    0x80
+#define NVIDIA_SMB_STS_ALRM    0x40
+#define NVIDIA_SMB_STS_RES     0x20
+#define NVIDIA_SMB_STS_STATUS  0x1f
+
+#define NVIDIA_SMB_PRTCL_WRITE                 0x00
+#define NVIDIA_SMB_PRTCL_READ                  0x01
+#define NVIDIA_SMB_PRTCL_QUICK                 0x02
+#define NVIDIA_SMB_PRTCL_BYTE                  0x04
+#define NVIDIA_SMB_PRTCL_BYTE_DATA             0x06
+#define NVIDIA_SMB_PRTCL_WORD_DATA             0x08
+#define NVIDIA_SMB_PRTCL_BLOCK_DATA            0x0a
+#define NVIDIA_SMB_PRTCL_PROC_CALL             0x0c
+#define NVIDIA_SMB_PRTCL_BLOCK_PROC_CALL       0x0d
+#define NVIDIA_SMB_PRTCL_I2C_BLOCK_DATA                0x4a
+#define NVIDIA_SMB_PRTCL_PEC                   0x80
+
+
+/* Other settings */
+#define MAX_TIMEOUT 256
+
+
+
+static s32 nforce2_access(struct i2c_adapter *adap, u16 addr,
+                      unsigned short flags, char read_write,
+                      u8 command, int size, union i2c_smbus_data *data);
+/*
+static int nforce2_block_transaction(union i2c_smbus_data *data,
+                                 char read_write, int i2c_enable);
+ */
+static u32 nforce2_func(struct i2c_adapter *adapter);
+
+
+static struct i2c_algorithm smbus_algorithm = {
+       .name = "Non-I2C SMBus adapter",
+       .id = I2C_ALGO_SMBUS,
+       .smbus_xfer = nforce2_access,
+       .functionality = nforce2_func,
+};
+
+/* Return -1 on error. See smbus.h for more information */
+s32 nforce2_access(struct i2c_adapter * adap, u16 addr, unsigned short flags,
+               char read_write, u8 command, int size,
+               union i2c_smbus_data * data)
+{
+       struct nforce2_smbus *smbus = adap->algo_data;
+       unsigned char protocol, pec, temp;
+       unsigned char len = 0; /* to keep the compiler quiet */
+       int timeout = 0;
+       int i;
+
+       protocol = (read_write == I2C_SMBUS_READ) ? NVIDIA_SMB_PRTCL_READ : NVIDIA_SMB_PRTCL_WRITE;
+       pec = (flags & I2C_CLIENT_PEC) ? NVIDIA_SMB_PRTCL_PEC : 0;
+
+       switch (size) {
+
+               case I2C_SMBUS_QUICK:
+                       protocol |= NVIDIA_SMB_PRTCL_QUICK;
+                       read_write = I2C_SMBUS_WRITE;
+                       break;
+
+               case I2C_SMBUS_BYTE:
+                       if (read_write == I2C_SMBUS_WRITE)
+                               outb_p(command, NVIDIA_SMB_CMD);
+                       protocol |= NVIDIA_SMB_PRTCL_BYTE;
+                       break;
+
+               case I2C_SMBUS_BYTE_DATA:
+                       outb_p(command, NVIDIA_SMB_CMD);
+                       if (read_write == I2C_SMBUS_WRITE)
+                               outb_p(data->byte, NVIDIA_SMB_DATA);
+                       protocol |= NVIDIA_SMB_PRTCL_BYTE_DATA;
+                       break;
+
+               case I2C_SMBUS_WORD_DATA:
+                       outb_p(command, NVIDIA_SMB_CMD);
+                       if (read_write == I2C_SMBUS_WRITE) {
+                                outb_p(data->word, NVIDIA_SMB_DATA);
+                                outb_p(data->word >> 8, NVIDIA_SMB_DATA+1);
+                       }
+                       protocol |= NVIDIA_SMB_PRTCL_WORD_DATA | pec;
+                       break;
+
+               case I2C_SMBUS_BLOCK_DATA:
+                       outb_p(command, NVIDIA_SMB_CMD);
+                       if (read_write == I2C_SMBUS_WRITE) {
+                               len = min_t(u8, data->block[0], 32);
+                               outb_p(len, NVIDIA_SMB_BCNT);
+                               for (i = 0; i < len; i++)
+                                       outb_p(data->block[i + 1], NVIDIA_SMB_DATA+i);
+                       }
+                       protocol |= NVIDIA_SMB_PRTCL_BLOCK_DATA | pec;
+                       break;
+
+               case I2C_SMBUS_I2C_BLOCK_DATA:
+                       len = min_t(u8, data->block[0], 32);
+                       outb_p(command, NVIDIA_SMB_CMD);
+                       outb_p(len, NVIDIA_SMB_BCNT);
+                       if (read_write == I2C_SMBUS_WRITE)
+                               for (i = 0; i < len; i++)
+                                       outb_p(data->block[i + 1], NVIDIA_SMB_DATA+i);
+                       protocol |= NVIDIA_SMB_PRTCL_I2C_BLOCK_DATA;
+                       break;
+
+               case I2C_SMBUS_PROC_CALL:
+                       printk(KERN_WARNING "i2c-nforce2.o: I2C_SMBUS_PROC_CALL not supported!\n");
+                       return -1;
+                       /*
+                       outb_p(command, NVIDIA_SMB_CMD);
+                       outb_p(data->word, NVIDIA_SMB_DATA);
+                       outb_p(data->word >> 8, NVIDIA_SMB_DATA + 1);
+                       protocol = NVIDIA_SMB_PRTCL_PROC_CALL | pec;
+                       read_write = I2C_SMBUS_READ;
+                       break;
+                        */
+
+               case I2C_SMBUS_BLOCK_PROC_CALL:
+                       printk(KERN_WARNING "i2c-nforce2.o: I2C_SMBUS_BLOCK_PROC_CALL not supported!\n");
+                       return -1;
+                       /*
+                       protocol |= pec;
+                       len = min_t(u8, data->block[0], 31);
+                       outb_p(command, NVIDIA_SMB_CMD);
+                       outb_p(len, NVIDIA_SMB_BCNT);
+                       for (i = 0; i < len; i++)
+                               outb_p(data->block[i + 1], NVIDIA_SMB_DATA + i);
+                       protocol = NVIDIA_SMB_PRTCL_BLOCK_PROC_CALL | pec;
+                       read_write = I2C_SMBUS_READ;
+                       break;
+                       */
+
+               case I2C_SMBUS_WORD_DATA_PEC:
+               case I2C_SMBUS_BLOCK_DATA_PEC:
+               case I2C_SMBUS_PROC_CALL_PEC:
+               case I2C_SMBUS_BLOCK_PROC_CALL_PEC:
+                       printk(KERN_WARNING "i2c-nforce2.c: Unexpected software PEC transaction %d\n.", size);
+                       return -1;
+
+               default:
+                       printk(KERN_WARNING "i2c-nforce2.c: Unsupported transaction %d\n", size);
+                       return -1;
+       }
+
+       outb_p((addr & 0x7f) << 1, NVIDIA_SMB_ADDR);
+       outb_p(protocol, NVIDIA_SMB_PRTCL);
+
+       temp = inb_p(NVIDIA_SMB_STS);
+
+#if 0
+       do {
+               i2c_delay(1);
+               temp = inb_p(NVIDIA_SMB_STS);
+       } while (((temp & NVIDIA_SMB_STS_DONE) == 0) && (timeout++ < MAX_TIMEOUT));
+#endif
+       if (~temp & NVIDIA_SMB_STS_DONE) {
+               udelay(500);
+               temp = inb_p(NVIDIA_SMB_STS);
+       }
+       if (~temp & NVIDIA_SMB_STS_DONE) {
+               i2c_delay(HZ/100);
+               temp = inb_p(NVIDIA_SMB_STS);
+       }
+
+       if ((timeout >= MAX_TIMEOUT) || (~temp & NVIDIA_SMB_STS_DONE) || (temp & NVIDIA_SMB_STS_STATUS))
+               return -1;
+
+       if (read_write == I2C_SMBUS_WRITE)
+               return 0;
+
+       switch (size) {
+
+               case I2C_SMBUS_BYTE:
+               case I2C_SMBUS_BYTE_DATA:
+                       data->byte = inb_p(NVIDIA_SMB_DATA);
+                       break;
+
+               case I2C_SMBUS_WORD_DATA:
+               /* case I2C_SMBUS_PROC_CALL: not supported */
+                       data->word = inb_p(NVIDIA_SMB_DATA) | (inb_p(NVIDIA_SMB_DATA+1) << 8);
+                       break;
+
+               case I2C_SMBUS_BLOCK_DATA:
+               /* case I2C_SMBUS_BLOCK_PROC_CALL: not supported */
+                       len = inb_p(NVIDIA_SMB_BCNT);
+                       len = min_t(u8, len, 32);
+               case I2C_SMBUS_I2C_BLOCK_DATA:
+                       for (i = 0; i < len; i++)
+                               data->block[i+1] = inb_p(NVIDIA_SMB_DATA + i);
+                       data->block[0] = len;
+                       break;
+       }
+
+       return 0;
+}
+
+
+u32 nforce2_func(struct i2c_adapter *adapter)
+{
+       /* other functionality might be possible, but is not tested */
+       return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
+           I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA /* |
+           I2C_FUNC_SMBUS_BLOCK_DATA */;
+}
+
+
+static struct pci_device_id nforce2_ids[] = {
+       { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE2_SMBUS,
+               PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
+       { 0 }
+};
+
+
+static int __devinit nforce2_probe_smb (struct pci_dev *dev, int reg, struct nforce2_smbus *smbus, char *name)
+{
+       u16 iobase;
+       int error;
+
+       if (pci_read_config_word(dev, reg, &iobase) != PCIBIOS_SUCCESSFUL) {
+               printk (KERN_ERR "i2c-nforce2.o: Error reading PCI config for %s\n", name);
+               return -1;
+       }
+       smbus->dev  = dev;
+       smbus->base = iobase & 0xfffc;
+       smbus->size = 8;
+
+       if (!request_region(smbus->base, smbus->size, "nForce2 SMBus")) {
+               printk (KERN_ERR "i2c-nforce2.o: Error requesting region %02x .. %02X for %s\n", smbus->base, smbus->base+smbus->size-1, name);
+               return -1;
+       }
+
+       /* TODO: find a better way to find out whether this file is compiled
+        * with i2c 2.7.0 of earlier
+        */
+#ifdef I2C_HW_SMBUS_AMD8111
+       smbus->adapter.owner = THIS_MODULE;
+#endif
+       sprintf(smbus->adapter.name, "SMBus nForce2 adapter at %04x", smbus->base);
+       smbus->adapter.id = I2C_ALGO_SMBUS | I2C_HW_SMBUS_NFORCE2;
+       smbus->adapter.algo = &smbus_algorithm;
+       smbus->adapter.algo_data = smbus;
+
+       error = i2c_add_adapter(&smbus->adapter);
+       if (error) {
+               printk(KERN_WARNING "i2c-nforce2.o: Failed to register adapter.\n");
+               release_region(smbus->base, smbus->size);
+               return -1;
+       }
+       printk(KERN_INFO "i2c-nforce2.o: nForce2 SMBus adapter at %#x\n", smbus->base);
+       return 0;
+}
+
+
+static int __devinit nforce2_probe(struct pci_dev *dev, const struct pci_device_id *id)
+{
+       struct nforce2_smbus *smbuses;
+       int res1, res2;
+
+       /* we support 2 SMBus adapters */
+       if (!(smbuses = (void *)kmalloc(2*sizeof(struct nforce2_smbus),
+                                       GFP_KERNEL)))
+               return -ENOMEM;
+       memset (smbuses, 0, 2*sizeof(struct nforce2_smbus));
+       pci_set_drvdata(dev, smbuses);
+
+       /* SMBus adapter 1 */
+       res1 = nforce2_probe_smb (dev, NFORCE_PCI_SMB1, &smbuses[0], "SMB1");
+       if (res1 < 0) {
+               printk (KERN_ERR "i2c-nforce2.o: Error probing SMB1.\n");
+               smbuses[0].base = 0;    /* to have a check value */
+       }
+       res2 = nforce2_probe_smb (dev, NFORCE_PCI_SMB2, &smbuses[1], "SMB2");
+       if (res2 < 0) {
+               printk (KERN_ERR "i2c-nforce2.o: Error probing SMB2.\n");
+               smbuses[1].base = 0;    /* to have a check value */
+       }
+       if ((res1 < 0) && (res2 < 0)) {
+               /* we did not find even one of the SMBuses, so we give up */
+               kfree(smbuses);
+               return -ENODEV;
+       }
+
+       return 0;
+}
+
+
+static void __devexit nforce2_remove(struct pci_dev *dev)
+{
+       struct nforce2_smbus *smbuses = (void*) pci_get_drvdata(dev);
+
+       if (smbuses[0].base) {
+               i2c_del_adapter(&smbuses[0].adapter);
+               release_region(smbuses[0].base, smbuses[0].size);
+       }
+       if (smbuses[1].base) {
+               i2c_del_adapter(&smbuses[1].adapter);
+               release_region(smbuses[1].base, smbuses[1].size);
+       }
+       kfree(smbuses);
+}
+
+static struct pci_driver nforce2_driver = {
+       .name           = "nForce2 SMBus",
+       .id_table       = nforce2_ids,
+       .probe          = nforce2_probe,
+       .remove         = __devexit_p(nforce2_remove),
+};
+
+int __init nforce2_init(void)
+{
+       printk(KERN_INFO "i2c-nforce2.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       return pci_module_init(&nforce2_driver);
+}
+
+void __exit nforce2_exit(void)
+{
+       pci_unregister_driver(&nforce2_driver);
+}
+
+module_init(nforce2_init);
+module_exit(nforce2_exit);
+
--- linux-old/drivers/i2c/i2c-piix4.c   Thu Jan  1 00:00:00 1970
+++ linux/drivers/i2c/i2c-piix4.c       Mon Dec 13 20:18:42 2004
@@ -0,0 +1,549 @@
+/*
+    piix4.c - Part of lm_sensors, Linux kernel modules for hardware
+              monitoring
+    Copyright (c) 1998 - 2002 Frodo Looijaard <frodol@dds.nl> and
+    Philip Edelbrock <phil@netroedge.com>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+   Supports:
+       Intel PIIX4, 440MX
+       Serverworks OSB4, CSB5, CSB6
+       SMSC Victory66
+
+   Note: we assume there can only be one device, with one SMBus interface.
+*/
+
+#include <linux/version.h>
+#include <linux/module.h>
+#include <linux/config.h>
+#include <linux/pci.h>
+#include <linux/kernel.h>
+#include <linux/stddef.h>
+#include <linux/sched.h>
+#include <linux/ioport.h>
+#include <linux/i2c.h>
+#include <linux/init.h>
+#include <linux/apm_bios.h>
+#include <asm/io.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+
+struct sd {
+       const unsigned short mfr;
+       const unsigned short dev;
+       const unsigned char fn;
+       const char *name;
+};
+
+/* PIIX4 SMBus address offsets */
+#define SMBHSTSTS (0 + piix4_smba)
+#define SMBHSLVSTS (1 + piix4_smba)
+#define SMBHSTCNT (2 + piix4_smba)
+#define SMBHSTCMD (3 + piix4_smba)
+#define SMBHSTADD (4 + piix4_smba)
+#define SMBHSTDAT0 (5 + piix4_smba)
+#define SMBHSTDAT1 (6 + piix4_smba)
+#define SMBBLKDAT (7 + piix4_smba)
+#define SMBSLVCNT (8 + piix4_smba)
+#define SMBSHDWCMD (9 + piix4_smba)
+#define SMBSLVEVT (0xA + piix4_smba)
+#define SMBSLVDAT (0xC + piix4_smba)
+
+/* count for request_region */
+#define SMBIOSIZE 8
+
+/* PCI Address Constants */
+#define SMBBA     0x090
+#define SMBHSTCFG 0x0D2
+#define SMBSLVC   0x0D3
+#define SMBSHDW1  0x0D4
+#define SMBSHDW2  0x0D5
+#define SMBREV    0x0D6
+
+/* Other settings */
+#define MAX_TIMEOUT 500
+#define  ENABLE_INT9 0
+
+/* PIIX4 constants */
+#define PIIX4_QUICK      0x00
+#define PIIX4_BYTE       0x04
+#define PIIX4_BYTE_DATA  0x08
+#define PIIX4_WORD_DATA  0x0C
+#define PIIX4_BLOCK_DATA 0x14
+
+/* insmod parameters */
+
+/* If force is set to anything different from 0, we forcibly enable the
+   PIIX4. DANGEROUS! */
+static int force = 0;
+MODULE_PARM(force, "i");
+MODULE_PARM_DESC(force, "Forcibly enable the PIIX4. DANGEROUS!");
+
+/* If force_addr is set to anything different from 0, we forcibly enable
+   the PIIX4 at the given address. VERY DANGEROUS! */
+static int force_addr = 0;
+MODULE_PARM(force_addr, "i");
+MODULE_PARM_DESC(force_addr,
+                "Forcibly enable the PIIX4 at the given address. "
+                "EXTREMELY DANGEROUS!");
+
+static int fix_hstcfg = 0;
+MODULE_PARM(fix_hstcfg, "i");
+MODULE_PARM_DESC(fix_hstcfg,
+                "Fix config register. Needed on some boards (Force CPCI735).");
+
+static int piix4_transaction(void);
+
+static unsigned short piix4_smba = 0;
+
+#ifdef CONFIG_X86
+/*
+ * Get DMI information.
+ */
+
+static int __devinit ibm_dmi_probe(void)
+{
+       extern int is_unsafe_smbus;
+       return is_unsafe_smbus;
+}
+#endif
+
+/* Detect whether a PIIX4 can be found, and initialize it, where necessary.
+   Note the differences between kernels with the old PCI BIOS interface and
+   newer kernels with the real PCI interface. In compat.h some things are
+   defined to make the transition easier. */
+static int __devinit piix4_setup(struct pci_dev *PIIX4_dev,
+                               const struct pci_device_id *id)
+{
+       unsigned char temp;
+
+       /* match up the function */
+       if (PCI_FUNC(PIIX4_dev->devfn) != id->driver_data)
+               return -ENODEV;
+
+       printk(KERN_INFO "Found %s device\n", PIIX4_dev->name);
+
+#ifdef CONFIG_X86
+       if(ibm_dmi_probe() && PIIX4_dev->vendor == PCI_VENDOR_ID_INTEL) {
+               printk(KERN_ERR "i2c-piix4.o: IBM Laptop detected; this module "
+                       "may corrupt your serial eeprom! Refusing to load "
+                       "module!\n");
+               return -EPERM;
+       }
+#endif
+
+       /* Determine the address of the SMBus areas */
+       if (force_addr) {
+               piix4_smba = force_addr & 0xfff0;
+               force = 0;
+       } else {
+               pci_read_config_word(PIIX4_dev, SMBBA, &piix4_smba);
+               piix4_smba &= 0xfff0;
+               if(piix4_smba == 0) {
+                       printk(KERN_ERR "i2c-piix4.o: SMB base address "
+                               "uninitialized - upgrade BIOS or use "
+                               "force_addr=0xaddr\n");
+                       return -ENODEV;
+               }
+       }
+
+       if (!request_region(piix4_smba, SMBIOSIZE, "piix4-smbus")) {
+               printk(KERN_ERR "i2c-piix4.o: SMB region 0x%x already in "
+                       "use!\n", piix4_smba);
+               return -ENODEV;
+       }
+
+       pci_read_config_byte(PIIX4_dev, SMBHSTCFG, &temp);
+
+       /* Some BIOS will set up the chipset incorrectly and leave a register
+          in an undefined state (causing I2C to act very strangely). */
+       if (temp & 0x02) {
+               if (fix_hstcfg) {
+                       printk(KERN_INFO "i2c-piix4.o: Working around buggy "
+                               "BIOS (I2C)\n");
+                       temp &= 0xfd;
+                       pci_write_config_byte(PIIX4_dev, SMBHSTCFG, temp);
+               } else {
+                       printk(KERN_INFO "i2c-piix4.o: Unusual config register "
+                               "value\n");
+                       printk(KERN_INFO "i2c-piix4.o: Try using fix_hstcfg=1 "
+                               "if you experience problems\n");
+               }
+       }
+
+       /* If force_addr is set, we program the new address here. Just to make
+          sure, we disable the PIIX4 first. */
+       if (force_addr) {
+               pci_write_config_byte(PIIX4_dev, SMBHSTCFG, temp & 0xfe);
+               pci_write_config_word(PIIX4_dev, SMBBA, piix4_smba);
+               pci_write_config_byte(PIIX4_dev, SMBHSTCFG, temp | 0x01);
+               printk(KERN_INFO "i2c-piix4.o: WARNING: SMBus interface set to "
+                       "new address %04x!\n", piix4_smba);
+       } else if ((temp & 1) == 0) {
+               if (force) {
+                       /* This should never need to be done, but has been
+                        * noted that many Dell machines have the SMBus
+                        * interface on the PIIX4 disabled!? NOTE: This assumes
+                        * I/O space and other allocations WERE done by the
+                        * Bios!  Don't complain if your hardware does weird
+                        * things after enabling this. :') Check for Bios
+                        * updates before resorting to this.
+                        */
+                       pci_write_config_byte(PIIX4_dev, SMBHSTCFG,
+                                             temp | 1);
+                       printk(KERN_NOTICE "i2c-piix4.o: WARNING: SMBus "
+                               "interface has been FORCEFULLY ENABLED!\n");
+               } else {
+                       printk(KERN_ERR "i2c-piix4.o: Host SMBus controller "
+                               "not enabled!\n");
+                       release_region(piix4_smba, SMBIOSIZE);
+                       piix4_smba = 0;
+                       return -ENODEV;
+               }
+       }
+
+#ifdef DEBUG
+       if ((temp & 0x0E) == 8)
+               printk(KERN_DEBUG "i2c-piix4.o: Using Interrupt 9 for "
+                       "SMBus.\n");
+       else if ((temp & 0x0E) == 0)
+               printk(KERN_DEBUG "i2c-piix4.o: Using Interrupt SMI# "
+                       "for SMBus.\n");
+       else
+               printk(KERN_ERR "i2c-piix4.o: Illegal Interrupt configuration "
+                       "(or code out of date)!\n");
+
+       pci_read_config_byte(PIIX4_dev, SMBREV, &temp);
+       printk(KERN_DEBUG "i2c-piix4.o: SMBREV = 0x%X\n", temp);
+       printk(KERN_DEBUG "i2c-piix4.o: SMBA = 0x%X\n", piix4_smba);
+#endif                         /* DEBUG */
+
+       return 0;
+}
+
+
+/* Another internally used function */
+int piix4_transaction(void)
+{
+       int temp;
+       int result = 0;
+       int timeout = 0;
+
+#ifdef DEBUG
+       printk
+           (KERN_DEBUG "i2c-piix4.o: Transaction (pre): CNT=%02x, CMD=%02x, ADD=%02x, DAT0=%02x, "
+            "DAT1=%02x\n", inb_p(SMBHSTCNT), inb_p(SMBHSTCMD),
+            inb_p(SMBHSTADD), inb_p(SMBHSTDAT0), inb_p(SMBHSTDAT1));
+#endif
+
+       /* Make sure the SMBus host is ready to start transmitting */
+       if ((temp = inb_p(SMBHSTSTS)) != 0x00) {
+#ifdef DEBUG
+               printk(KERN_DEBUG "i2c-piix4.o: SMBus busy (%02x). Resetting... \n",
+                      temp);
+#endif
+               outb_p(temp, SMBHSTSTS);
+               if ((temp = inb_p(SMBHSTSTS)) != 0x00) {
+#ifdef DEBUG
+                       printk(KERN_ERR "i2c-piix4.o: Failed! (%02x)\n", temp);
+#endif
+                       return -1;
+               } else {
+#ifdef DEBUG
+                       printk(KERN_DEBUG "i2c-piix4.o: Successfull!\n");
+#endif
+               }
+       }
+
+       /* start the transaction by setting bit 6 */
+       outb_p(inb(SMBHSTCNT) | 0x040, SMBHSTCNT);
+
+       /* We will always wait for a fraction of a second! (See PIIX4 docs errata) */
+       do {
+               i2c_delay(1);
+               temp = inb_p(SMBHSTSTS);
+       } while ((temp & 0x01) && (timeout++ < MAX_TIMEOUT));
+
+#ifdef DEBUG
+       /* If the SMBus is still busy, we give up */
+       if (timeout >= MAX_TIMEOUT) {
+               printk(KERN_ERR "i2c-piix4.o: SMBus Timeout!\n");
+               result = -1;
+       }
+#endif
+
+       if (temp & 0x10) {
+               result = -1;
+#ifdef DEBUG
+               printk(KERN_ERR "i2c-piix4.o: Error: Failed bus transaction\n");
+#endif
+       }
+
+       if (temp & 0x08) {
+               result = -1;
+               printk
+                   (KERN_ERR "i2c-piix4.o: Bus collision! SMBus may be locked until next hard\n"
+                    "reset. (sorry!)\n");
+               /* Clock stops and slave is stuck in mid-transmission */
+       }
+
+       if (temp & 0x04) {
+               result = -1;
+#ifdef DEBUG
+               printk(KERN_ERR "i2c-piix4.o: Error: no response!\n");
+#endif
+       }
+
+       if (inb_p(SMBHSTSTS) != 0x00)
+               outb_p(inb(SMBHSTSTS), SMBHSTSTS);
+
+#ifdef DEBUG
+       if ((temp = inb_p(SMBHSTSTS)) != 0x00) {
+               printk
+                   (KERN_ERR "i2c-piix4.o: Failed reset at end of transaction (%02x)\n",
+                    temp);
+       }
+       printk
+           (KERN_DEBUG "i2c-piix4.o: Transaction (post): CNT=%02x, CMD=%02x, ADD=%02x, "
+            "DAT0=%02x, DAT1=%02x\n", inb_p(SMBHSTCNT), inb_p(SMBHSTCMD),
+            inb_p(SMBHSTADD), inb_p(SMBHSTDAT0), inb_p(SMBHSTDAT1));
+#endif
+       return result;
+}
+
+/* Return -1 on error. */
+s32 piix4_access(struct i2c_adapter * adap, u16 addr,
+                unsigned short flags, char read_write,
+                u8 command, int size, union i2c_smbus_data * data)
+{
+       int i, len;
+
+       switch (size) {
+       case I2C_SMBUS_QUICK:
+               outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
+                      SMBHSTADD);
+               size = PIIX4_QUICK;
+               break;
+       case I2C_SMBUS_BYTE:
+               outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
+                      SMBHSTADD);
+               if (read_write == I2C_SMBUS_WRITE)
+                       outb_p(command, SMBHSTCMD);
+               size = PIIX4_BYTE;
+               break;
+       case I2C_SMBUS_BYTE_DATA:
+               outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
+                      SMBHSTADD);
+               outb_p(command, SMBHSTCMD);
+               if (read_write == I2C_SMBUS_WRITE)
+                       outb_p(data->byte, SMBHSTDAT0);
+               size = PIIX4_BYTE_DATA;
+               break;
+       case I2C_SMBUS_WORD_DATA:
+               outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
+                      SMBHSTADD);
+               outb_p(command, SMBHSTCMD);
+               if (read_write == I2C_SMBUS_WRITE) {
+                       outb_p(data->word & 0xff, SMBHSTDAT0);
+                       outb_p((data->word & 0xff00) >> 8, SMBHSTDAT1);
+               }
+               size = PIIX4_WORD_DATA;
+               break;
+       case I2C_SMBUS_BLOCK_DATA:
+               outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
+                      SMBHSTADD);
+               outb_p(command, SMBHSTCMD);
+               if (read_write == I2C_SMBUS_WRITE) {
+                       len = data->block[0];
+                       if (len < 0)
+                               len = 0;
+                       if (len > 32)
+                               len = 32;
+                       outb_p(len, SMBHSTDAT0);
+                       i = inb_p(SMBHSTCNT);   /* Reset SMBBLKDAT */
+                       for (i = 1; i <= len; i++)
+                               outb_p(data->block[i], SMBBLKDAT);
+               }
+               size = PIIX4_BLOCK_DATA;
+               break;
+       default:
+               printk
+                   (KERN_WARNING "i2c-piix4.o: Unsupported transaction %d\n", size);
+               return -1;
+       }
+
+       outb_p((size & 0x1C) + (ENABLE_INT9 & 1), SMBHSTCNT);
+
+       if (piix4_transaction())        /* Error in transaction */
+               return -1;
+
+       if ((read_write == I2C_SMBUS_WRITE) || (size == PIIX4_QUICK))
+               return 0;
+
+
+       switch (size) {
+       case PIIX4_BYTE:        /* Where is the result put? I assume here it is in
+                                  SMBHSTDAT0 but it might just as well be in the
+                                  SMBHSTCMD. No clue in the docs */
+
+               data->byte = inb_p(SMBHSTDAT0);
+               break;
+       case PIIX4_BYTE_DATA:
+               data->byte = inb_p(SMBHSTDAT0);
+               break;
+       case PIIX4_WORD_DATA:
+               data->word = inb_p(SMBHSTDAT0) + (inb_p(SMBHSTDAT1) << 8);
+               break;
+       case PIIX4_BLOCK_DATA:
+               data->block[0] = inb_p(SMBHSTDAT0);
+               i = inb_p(SMBHSTCNT);   /* Reset SMBBLKDAT */
+               for (i = 1; i <= data->block[0]; i++)
+                       data->block[i] = inb_p(SMBBLKDAT);
+               break;
+       }
+       return 0;
+}
+
+
+u32 piix4_func(struct i2c_adapter *adapter)
+{
+       return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
+           I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
+           I2C_FUNC_SMBUS_BLOCK_DATA;
+}
+
+static struct i2c_algorithm smbus_algorithm = {
+       .name           = "Non-I2C SMBus adapter",
+       .id             = I2C_ALGO_SMBUS,
+       .smbus_xfer     = piix4_access,
+       .functionality  = piix4_func,
+};
+
+static struct i2c_adapter piix4_adapter = {
+       .owner          = THIS_MODULE,
+       .name           = "unset",
+       .id             = I2C_ALGO_SMBUS | I2C_HW_SMBUS_PIIX4,
+       .algo           = &smbus_algorithm,
+};
+
+#ifndef PCI_DEVICE_ID_SERVERWORKS_CSB6
+#define PCI_DEVICE_ID_SERVERWORKS_CSB6 0x0203
+#endif
+
+static struct pci_device_id piix4_ids[] __devinitdata = {
+       {
+               .vendor =       PCI_VENDOR_ID_INTEL,
+               .device =       PCI_DEVICE_ID_INTEL_82371AB_3,
+               .subvendor =    PCI_ANY_ID,
+               .subdevice =    PCI_ANY_ID,
+               .driver_data =  3
+       },
+       {
+               .vendor =       PCI_VENDOR_ID_SERVERWORKS,
+               .device =       PCI_DEVICE_ID_SERVERWORKS_OSB4,
+               .subvendor =    PCI_ANY_ID,
+               .subdevice =    PCI_ANY_ID,
+               .driver_data =  0,
+       },
+       {
+               .vendor =       PCI_VENDOR_ID_SERVERWORKS,
+               .device =       PCI_DEVICE_ID_SERVERWORKS_CSB5,
+               .subvendor =    PCI_ANY_ID,
+               .subdevice =    PCI_ANY_ID,
+               .driver_data =  0,
+       },
+       {
+               .vendor =       PCI_VENDOR_ID_SERVERWORKS,
+               .device =       PCI_DEVICE_ID_SERVERWORKS_CSB6,
+               .subvendor =    PCI_ANY_ID,
+               .subdevice =    PCI_ANY_ID,
+               .driver_data =  0,
+       },
+       {
+               .vendor =       PCI_VENDOR_ID_INTEL,
+               .device =       PCI_DEVICE_ID_INTEL_82443MX_3,
+               .subvendor =    PCI_ANY_ID,
+               .subdevice =    PCI_ANY_ID,
+               .driver_data =  3,
+       },
+       {
+               .vendor =       PCI_VENDOR_ID_EFAR,
+               .device =       PCI_DEVICE_ID_EFAR_SLC90E66_3,
+               .subvendor =    PCI_ANY_ID,
+               .subdevice =    PCI_ANY_ID,
+               .driver_data =  0,
+       },
+       { 0, }
+};
+
+static int __devinit piix4_probe(struct pci_dev *dev,
+                               const struct pci_device_id *id)
+{
+       int retval;
+
+       retval = piix4_setup(dev, id);
+       if (retval)
+               return retval;
+
+       sprintf(piix4_adapter.name, "SMBus PIIX4 adapter at %04x",
+               piix4_smba);
+
+       if ((retval = i2c_add_adapter(&piix4_adapter))) {
+               printk(KERN_ERR "i2c-piix4.o: Couldn't register adapter!\n");
+               release_region(piix4_smba, SMBIOSIZE);
+               piix4_smba = 0;
+       }
+
+       return retval;
+}
+
+static void __devexit piix4_remove(struct pci_dev *dev)
+{
+       if (piix4_smba) {
+               i2c_del_adapter(&piix4_adapter);
+               release_region(piix4_smba, SMBIOSIZE);
+               piix4_smba = 0;
+       }
+}
+
+static struct pci_driver piix4_driver = {
+       .name           = "piix4 smbus",
+       .id_table       = piix4_ids,
+       .probe          = piix4_probe,
+       .remove         = __devexit_p(piix4_remove),
+};
+
+static int __init i2c_piix4_init(void)
+{
+       printk("i2c-piix4.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       return pci_module_init(&piix4_driver);
+}
+
+static void __exit i2c_piix4_exit(void)
+{
+       pci_unregister_driver(&piix4_driver);
+}
+
+MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl> and "
+               "Philip Edelbrock <phil@netroedge.com>");
+MODULE_DESCRIPTION("PIIX4 SMBus driver");
+MODULE_LICENSE("GPL");
+
+module_init(i2c_piix4_init);
+module_exit(i2c_piix4_exit);
--- linux-old/drivers/i2c/i2c-savage4.c Thu Jan  1 00:00:00 1970
+++ linux/drivers/i2c/i2c-savage4.c     Mon Dec 13 20:18:42 2004
@@ -0,0 +1,229 @@
+/*
+    i2c-savage4.c - Part of lm_sensors, Linux kernel modules for hardware
+              monitoring
+    Copyright (C) 1998-2003  The LM Sensors Team
+    Alexander Wold <awold@bigfoot.com>
+    Mark D. Studebaker <mdsxyz123@yahoo.com>
+    
+    Based on i2c-voodoo3.c.
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/* This interfaces to the I2C bus of the Savage4 to gain access to
+   the BT869 and possibly other I2C devices. The DDC bus is not
+   yet supported because its register is not memory-mapped.
+   However we leave the DDC code here, commented out, to make
+   it easier to add later.
+*/
+
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/i2c.h>
+#include <linux/i2c-algo-bit.h>
+#include <linux/init.h>
+#include <asm/io.h>
+#include <asm/param.h> /* for HZ */
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+/* 3DFX defines */
+/* #define PCI_VENDOR_ID_S3            0x5333 */
+#define PCI_CHIP_SAVAGE3D      0x8A20
+#define PCI_CHIP_SAVAGE3D_MV   0x8A21
+#define PCI_CHIP_SAVAGE4       0x8A22
+#define PCI_CHIP_SAVAGE2000    0x9102
+#define PCI_CHIP_PROSAVAGE_PM  0x8A25
+#define PCI_CHIP_PROSAVAGE_KM  0x8A26
+#define PCI_CHIP_SAVAGE_MX_MV  0x8c10
+#define PCI_CHIP_SAVAGE_MX     0x8c11
+#define PCI_CHIP_SAVAGE_IX_MV  0x8c12
+#define PCI_CHIP_SAVAGE_IX     0x8c13
+
+#define REG 0xff20     /* Serial Port 1 Register */
+
+/* bit locations in the register */
+//#define DDC_ENAB     0x00040000
+//#define DDC_SCL_OUT  0x00080000
+//#define DDC_SDA_OUT  0x00100000
+//#define DDC_SCL_IN   0x00200000
+//#define DDC_SDA_IN   0x00400000
+#define I2C_ENAB       0x00000020
+#define I2C_SCL_OUT    0x00000001
+#define I2C_SDA_OUT    0x00000002
+#define I2C_SCL_IN     0x00000008
+#define I2C_SDA_IN     0x00000010
+
+/* initialization states */
+#define INIT2  0x20
+/* #define INIT3       0x4 */
+
+/* delays */
+#define CYCLE_DELAY    10
+#define TIMEOUT                (HZ / 2)
+
+
+static void config_s4(struct pci_dev *dev);
+
+static unsigned long ioaddr;
+
+/* The sav GPIO registers don't have individual masks for each bit
+   so we always have to read before writing. */
+
+static void bit_savi2c_setscl(void *data, int val)
+{
+       unsigned int r;
+       r = readl(ioaddr + REG);
+       if(val)
+               r |= I2C_SCL_OUT;
+       else
+               r &= ~I2C_SCL_OUT;
+       writel(r, ioaddr + REG);
+       readl(ioaddr + REG);    /* flush posted write */
+}
+
+static void bit_savi2c_setsda(void *data, int val)
+{
+       unsigned int r;
+       r = readl(ioaddr + REG);
+       if(val)
+               r |= I2C_SDA_OUT;
+       else
+               r &= ~I2C_SDA_OUT;
+       writel(r, ioaddr + REG);
+       readl(ioaddr + REG);    /* flush posted write */
+}
+
+/* The GPIO pins are open drain, so the pins always remain outputs.
+   We rely on the i2c-algo-bit routines to set the pins high before
+   reading the input from other chips. */
+
+static int bit_savi2c_getscl(void *data)
+{
+       return (0 != (readl(ioaddr + REG) & I2C_SCL_IN));
+}
+
+static int bit_savi2c_getsda(void *data)
+{
+       return (0 != (readl(ioaddr + REG) & I2C_SDA_IN));
+}
+
+/* Configures the chip */
+
+void config_s4(struct pci_dev *dev)
+{
+       unsigned int cadr;
+
+       /* map memory */
+       cadr = dev->resource[0].start;
+       cadr &= PCI_BASE_ADDRESS_MEM_MASK;
+       ioaddr = (unsigned long)ioremap_nocache(cadr, 0x0080000);
+       if(ioaddr) {
+//             writel(0x8160, ioaddr + REG2);
+               writel(0x00000020, ioaddr + REG);
+               printk("i2c-savage4: Using Savage4 at 0x%lx\n", ioaddr);
+       }
+}
+
+
+static struct i2c_algo_bit_data sav_i2c_bit_data = {
+       .setsda         = bit_savi2c_setsda,
+       .setscl         = bit_savi2c_setscl,
+       .getsda         = bit_savi2c_getsda,
+       .getscl         = bit_savi2c_getscl,
+       .udelay         = CYCLE_DELAY,
+       .mdelay         = CYCLE_DELAY,
+       .timeout        = TIMEOUT
+};
+
+static struct i2c_adapter savage4_i2c_adapter = {
+       .owner          = THIS_MODULE,
+       .name           = "I2C Savage4 adapter",
+       .id             = I2C_HW_B_SAVG,
+       .algo_data      = &sav_i2c_bit_data,
+};
+
+static struct pci_device_id savage4_ids[] __devinitdata = {
+       {
+               .vendor =       PCI_VENDOR_ID_S3,
+               .device =       PCI_CHIP_SAVAGE4,
+               .subvendor =    PCI_ANY_ID,
+               .subdevice =    PCI_ANY_ID,
+       },
+       {
+               .vendor =       PCI_VENDOR_ID_S3,
+               .device =       PCI_CHIP_SAVAGE2000,
+               .subvendor =    PCI_ANY_ID,
+               .subdevice =    PCI_ANY_ID,
+       },
+       { 0, }
+};
+
+static int __devinit savage4_probe(struct pci_dev *dev, const struct pci_device_id *id)
+{
+       config_s4(dev);
+       return i2c_bit_add_bus(&savage4_i2c_adapter);
+}
+
+static void __devexit savage4_remove(struct pci_dev *dev)
+{
+       i2c_bit_del_bus(&savage4_i2c_adapter);
+}
+
+
+/* Don't register driver to avoid driver conflicts */
+/*
+static struct pci_driver savage4_driver = {
+       .name           = "savage4 smbus",
+       .id_table       = savage4_ids,
+       .probe          = savage4_probe,
+       .remove         = __devexit_p(savage4_remove),
+};
+*/
+
+static int __init i2c_savage4_init(void)
+{
+       struct pci_dev *dev;
+       const struct pci_device_id *id;
+
+       printk("i2c-savage4.o version %s (%s)\n", LM_VERSION, LM_DATE);
+/*
+       return pci_module_init(&savage4_driver);
+*/
+       pci_for_each_dev(dev) {
+               id = pci_match_device(savage4_ids, dev);
+               if(id)
+                       if(savage4_probe(dev, id) >= 0)
+                               return 0;
+       }
+       return -ENODEV;
+}
+
+static void __exit i2c_savage4_exit(void)
+{
+/*
+       pci_unregister_driver(&savage4_driver);
+*/
+       savage4_remove(NULL);
+       iounmap((void *)ioaddr);
+}
+
+MODULE_AUTHOR("Alexander Wold <awold@bigfoot.com> "
+               "and Mark D. Studebaker <mdsxyz123@yahoo.com>");
+MODULE_DESCRIPTION("Savage4 I2C/SMBus driver");
+MODULE_LICENSE("GPL");
+
+module_init(i2c_savage4_init);
+module_exit(i2c_savage4_exit);
--- linux-old/drivers/i2c/i2c-sis5595.c Thu Jan  1 00:00:00 1970
+++ linux/drivers/i2c/i2c-sis5595.c     Mon Dec 13 20:18:42 2004
@@ -0,0 +1,481 @@
+/*
+    sis5595.c - Part of lm_sensors, Linux kernel modules for hardware
+              monitoring
+    Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl> and
+    Philip Edelbrock <phil@netroedge.com>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/* Note: we assume there can only be one SIS5595 with one SMBus interface */
+
+/*
+   Note: all have mfr. ID 0x1039.
+   SUPPORTED           PCI ID          
+       5595            0008
+
+   Note: these chips contain a 0008 device which is incompatible with the
+         5595. We recognize these by the presence of the listed
+         "blacklist" PCI ID and refuse to load.
+
+   NOT SUPPORTED       PCI ID          BLACKLIST PCI ID        
+        540            0008            0540
+        550            0008            0550
+       5513            0008            5511
+       5581            0008            5597
+       5582            0008            5597
+       5597            0008            5597
+       5598            0008            5597/5598
+        630            0008            0630
+        645            0008            0645
+        646            0008            0646
+        648            0008            0648
+        650            0008            0650
+        651            0008            0651
+        730            0008            0730
+        735            0008            0735
+        745            0008            0745
+        746            0008            0746
+*/
+
+/* TO DO: 
+ * Add Block Transfers (ugly, but supported by the adapter)
+ * Add adapter resets
+ */
+
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/kernel.h>
+#include <linux/stddef.h>
+#include <linux/sched.h>
+#include <linux/ioport.h>
+#include <linux/i2c.h>
+#include <linux/init.h>
+#include <asm/io.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+MODULE_LICENSE("GPL");
+
+static int blacklist[] = {
+                       PCI_DEVICE_ID_SI_540,
+                       PCI_DEVICE_ID_SI_550,
+                       PCI_DEVICE_ID_SI_630,
+                       PCI_DEVICE_ID_SI_730,
+                       PCI_DEVICE_ID_SI_5511, /* 5513 chip has the 0008 device but
+                                                 that ID shows up in other chips so we
+                                                 use the 5511 ID for recognition */
+                       PCI_DEVICE_ID_SI_5597,
+                       PCI_DEVICE_ID_SI_5598,
+                       0x645,
+                       0x646,
+                       0x648,
+                       0x650,
+                       0x651,
+                       0x735,
+                       0x745,
+                       0x746,
+                       0 };
+
+/* Length of ISA address segment */
+#define SIS5595_EXTENT 8
+/* SIS5595 SMBus registers */
+#define SMB_STS_LO 0x00
+#define SMB_STS_HI 0x01
+#define SMB_CTL_LO 0x02
+#define SMB_CTL_HI 0x03
+#define SMB_ADDR   0x04
+#define SMB_CMD    0x05
+#define SMB_PCNT   0x06
+#define SMB_CNT    0x07
+#define SMB_BYTE   0x08
+#define SMB_DEV    0x10
+#define SMB_DB0    0x11
+#define SMB_DB1    0x12
+#define SMB_HAA    0x13
+
+/* PCI Address Constants */
+#define SMB_INDEX  0x38
+#define SMB_DAT    0x39
+#define SIS5595_ENABLE_REG 0x40
+#define ACPI_BASE  0x90
+
+/* Other settings */
+#define MAX_TIMEOUT 500
+
+/* SIS5595 constants */
+#define SIS5595_QUICK      0x00
+#define SIS5595_BYTE       0x02
+#define SIS5595_BYTE_DATA  0x04
+#define SIS5595_WORD_DATA  0x06
+#define SIS5595_PROC_CALL  0x08
+#define SIS5595_BLOCK_DATA 0x0A
+
+/* insmod parameters */
+
+/* If force_addr is set to anything different from 0, we forcibly enable
+   the device at the given address. */
+static int force_addr = 0;
+MODULE_PARM(force_addr, "i");
+MODULE_PARM_DESC(force_addr,
+                "Initialize the base address of the i2c controller");
+
+static int sis5595_transaction(void);
+
+static unsigned short sis5595_base = 0;
+
+static u8 sis5595_read(u8 reg)
+{
+       outb(reg, sis5595_base + SMB_INDEX);
+       return inb(sis5595_base + SMB_DAT);
+}
+
+static void sis5595_write(u8 reg, u8 data)
+{
+       outb(reg, sis5595_base + SMB_INDEX);
+       outb(data, sis5595_base + SMB_DAT);
+}
+
+
+/* Detect whether a SIS5595 can be found, and initialize it, where necessary.
+   Note the differences between kernels with the old PCI BIOS interface and
+   newer kernels with the real PCI interface. In compat.h some things are
+   defined to make the transition easier. */
+int sis5595_setup(struct pci_dev *SIS5595_dev)
+{
+       u16 a;
+       u8 val;
+       int *i;
+
+       /* Look for imposters */
+       for(i = blacklist; *i != 0; i++) {
+               if (pci_find_device(PCI_VENDOR_ID_SI, *i, NULL)) {
+                       printk("i2c-sis5595.o: Error: Looked for SIS5595 but found unsupported device %.4X\n", *i);
+                       return -ENODEV;
+               }
+       }
+
+/* Determine the address of the SMBus areas */
+       pci_read_config_word(SIS5595_dev, ACPI_BASE, &sis5595_base);
+       if(sis5595_base == 0 && force_addr == 0) {
+               printk("i2c-sis5595.o: ACPI base address uninitialized - upgrade BIOS or use force_addr=0xaddr\n");
+               return -ENODEV;
+       }
+
+       if(force_addr)
+               sis5595_base = force_addr & ~(SIS5595_EXTENT - 1);
+#ifdef DEBUG
+       printk("ACPI Base address: %04x\n", sis5595_base);
+#endif
+       /* NB: We grab just the two SMBus registers here, but this may still
+        * interfere with ACPI :-(  */
+       if (check_region(sis5595_base + SMB_INDEX, 2)) {
+               printk
+                   ("i2c-sis5595.o: SMBus registers 0x%04x-0x%04x already in use!\n",
+                    sis5595_base + SMB_INDEX,
+                    sis5595_base + SMB_INDEX + 1);
+               return -ENODEV;
+       }
+
+       if(force_addr) {
+               printk("i2c-sis5595.o: forcing ISA address 0x%04X\n", sis5595_base);
+               if (PCIBIOS_SUCCESSFUL !=
+                   pci_write_config_word(SIS5595_dev, ACPI_BASE, sis5595_base))
+                       return -ENODEV;
+               if (PCIBIOS_SUCCESSFUL !=
+                   pci_read_config_word(SIS5595_dev, ACPI_BASE, &a))
+                       return -ENODEV;
+               if ((a & ~(SIS5595_EXTENT - 1)) != sis5595_base) {
+                       /* doesn't work for some chips! */
+                       printk("i2c-sis5595.o: force address failed - not supported?\n");
+                       return -ENODEV;
+               }
+       }
+
+       if (PCIBIOS_SUCCESSFUL !=
+           pci_read_config_byte(SIS5595_dev, SIS5595_ENABLE_REG, &val))
+               return -ENODEV;
+       if((val & 0x80) == 0) {
+               printk("sis5595.o: enabling ACPI\n");
+               if (PCIBIOS_SUCCESSFUL !=
+                   pci_write_config_byte(SIS5595_dev, SIS5595_ENABLE_REG,
+                                     val | 0x80))
+                       return -ENODEV;
+               if (PCIBIOS_SUCCESSFUL !=
+                   pci_read_config_byte(SIS5595_dev, SIS5595_ENABLE_REG, &val))
+                       return -ENODEV;
+               if((val & 0x80) == 0) { /* doesn't work for some chips? */
+                       printk("sis5595.o: ACPI enable failed - not supported?\n");
+                       return -ENODEV;
+               }
+       }
+
+       /* Everything is happy, let's grab the memory and set things up. */
+       request_region(sis5595_base + SMB_INDEX, 2, "sis5595-smbus");
+       return(0);
+}
+
+
+/* Another internally used function */
+int sis5595_transaction(void)
+{
+       int temp;
+       int result = 0;
+       int timeout = 0;
+
+       /* Make sure the SMBus host is ready to start transmitting */
+       if (
+           (temp =
+            sis5595_read(SMB_STS_LO) + (sis5595_read(SMB_STS_HI) << 8)) !=
+           0x00) {
+#ifdef DEBUG
+               printk("i2c-sis5595.o: SMBus busy (%04x). Resetting... \n",
+                      temp);
+#endif
+               sis5595_write(SMB_STS_LO, temp & 0xff);
+               sis5595_write(SMB_STS_HI, temp >> 8);
+               if (
+                   (temp =
+                    sis5595_read(SMB_STS_LO) +
+                    (sis5595_read(SMB_STS_HI) << 8)) != 0x00) {
+#ifdef DEBUG
+                       printk("i2c-sis5595.o: Failed! (%02x)\n", temp);
+#endif
+                       return -1;
+               } else {
+#ifdef DEBUG
+                       printk("i2c-sis5595.o: Successfull!\n");
+#endif
+               }
+       }
+
+       /* start the transaction by setting bit 4 */
+       sis5595_write(SMB_CTL_LO, sis5595_read(SMB_CTL_LO) | 0x10);
+
+       /* We will always wait for a fraction of a second! */
+       do {
+               i2c_delay(1);
+               temp = sis5595_read(SMB_STS_LO);
+       } while (!(temp & 0x40) && (timeout++ < MAX_TIMEOUT));
+
+       /* If the SMBus is still busy, we give up */
+       if (timeout >= MAX_TIMEOUT) {
+#ifdef DEBUG
+               printk("i2c-sis5595.o: SMBus Timeout!\n");
+#endif
+               result = -1;
+       }
+
+       if (temp & 0x10) {
+               result = -1;
+#ifdef DEBUG
+               printk("i2c-sis5595.o: Error: Failed bus transaction\n");
+#endif
+       }
+
+       if (temp & 0x20) {
+               result = -1;
+               printk
+                   ("i2c-sis5595.o: Bus collision! SMBus may be locked until next hard\n"
+                    "reset (or not...)\n");
+               /* Clock stops and slave is stuck in mid-transmission */
+       }
+
+       if (
+           (temp =
+            sis5595_read(SMB_STS_LO) + (sis5595_read(SMB_STS_HI) << 8)) !=
+           0x00) {
+               sis5595_write(SMB_STS_LO, temp & 0xff);
+               sis5595_write(SMB_STS_HI, temp >> 8);
+       }
+
+       if (
+           (temp =
+            sis5595_read(SMB_STS_LO) + (sis5595_read(SMB_STS_HI) << 8)) !=
+           0x00) {
+
+#ifdef DEBUG
+               printk
+                   ("i2c-sis5595.o: Failed reset at end of transaction (%02x)\n",
+                    temp);
+#endif
+       }
+       return result;
+}
+
+/* Return -1 on error. */
+s32 sis5595_access(struct i2c_adapter * adap, u16 addr,
+                  unsigned short flags, char read_write,
+                  u8 command, int size, union i2c_smbus_data * data)
+{
+       switch (size) {
+       case I2C_SMBUS_QUICK:
+               sis5595_write(SMB_ADDR,
+                             ((addr & 0x7f) << 1) | (read_write & 0x01));
+               size = SIS5595_QUICK;
+               break;
+       case I2C_SMBUS_BYTE:
+               sis5595_write(SMB_ADDR,
+                             ((addr & 0x7f) << 1) | (read_write & 0x01));
+               if (read_write == I2C_SMBUS_WRITE)
+                       sis5595_write(SMB_CMD, command);
+               size = SIS5595_BYTE;
+               break;
+       case I2C_SMBUS_BYTE_DATA:
+               sis5595_write(SMB_ADDR,
+                             ((addr & 0x7f) << 1) | (read_write & 0x01));
+               sis5595_write(SMB_CMD, command);
+               if (read_write == I2C_SMBUS_WRITE)
+                       sis5595_write(SMB_BYTE, data->byte);
+               size = SIS5595_BYTE_DATA;
+               break;
+       case I2C_SMBUS_PROC_CALL:
+       case I2C_SMBUS_WORD_DATA:
+               sis5595_write(SMB_ADDR,
+                             ((addr & 0x7f) << 1) | (read_write & 0x01));
+               sis5595_write(SMB_CMD, command);
+               if (read_write == I2C_SMBUS_WRITE) {
+                       sis5595_write(SMB_BYTE, data->word & 0xff);
+                       sis5595_write(SMB_BYTE + 1,
+                                     (data->word & 0xff00) >> 8);
+               }
+               size =
+                   (size ==
+                    I2C_SMBUS_PROC_CALL) ? SIS5595_PROC_CALL :
+                   SIS5595_WORD_DATA;
+               break;
+/*
+       case I2C_SMBUS_BLOCK_DATA:
+               printk("sis5595.o: Block data not yet implemented!\n");
+               return -1;
+               break;
+*/
+       default:
+               printk
+                   (KERN_WARNING "sis5595.o: Unsupported transaction %d\n", size);
+               return -1;
+       }
+
+       sis5595_write(SMB_CTL_LO, ((size & 0x0E)));
+
+       if (sis5595_transaction())      /* Error in transaction */
+               return -1;
+
+       if ((size != SIS5595_PROC_CALL) &&
+           ((read_write == I2C_SMBUS_WRITE) || (size == SIS5595_QUICK)))
+               return 0;
+
+
+       switch (size) {
+       case SIS5595_BYTE:      /* Where is the result put? I assume here it is in
+                                  SMB_DATA but it might just as well be in the
+                                  SMB_CMD. No clue in the docs */
+       case SIS5595_BYTE_DATA:
+               data->byte = sis5595_read(SMB_BYTE);
+               break;
+       case SIS5595_WORD_DATA:
+       case SIS5595_PROC_CALL:
+               data->word =
+                   sis5595_read(SMB_BYTE) +
+                   (sis5595_read(SMB_BYTE + 1) << 8);
+               break;
+       }
+       return 0;
+}
+
+
+u32 sis5595_func(struct i2c_adapter *adapter)
+{
+       return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
+           I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
+           I2C_FUNC_SMBUS_PROC_CALL;
+}
+
+
+static struct i2c_algorithm smbus_algorithm = {
+       .name           = "Non-I2C SMBus adapter",
+       .id             = I2C_ALGO_SMBUS,
+       .smbus_xfer     = sis5595_access,
+       .functionality  = sis5595_func,
+};
+
+static struct i2c_adapter sis5595_adapter = {
+       .owner          = THIS_MODULE,
+       .name           = "unset",
+       .id             = I2C_ALGO_SMBUS | I2C_HW_SMBUS_SIS5595,
+       .algo           = &smbus_algorithm,
+};
+
+
+static struct pci_device_id sis5595_ids[] __devinitdata = {
+       {
+               .vendor =       PCI_VENDOR_ID_SI,
+               .device =       PCI_DEVICE_ID_SI_503,
+               .subvendor =    PCI_ANY_ID,
+               .subdevice =    PCI_ANY_ID,
+       },
+       { 0, }
+};
+
+static int __devinit sis5595_probe(struct pci_dev *dev, const struct pci_device_id *id)
+{
+
+       if (sis5595_setup(dev)) {
+               printk
+                   ("i2c-sis5595.o: SIS5595 not detected, module not inserted.\n");
+
+               return -ENODEV;
+       }
+
+       sprintf(sis5595_adapter.name, "SMBus SIS5595 adapter at %04x",
+               sis5595_base + SMB_INDEX);
+       i2c_add_adapter(&sis5595_adapter);
+
+       return 0;
+}
+
+static void __devexit sis5595_remove(struct pci_dev *dev)
+{
+       i2c_del_adapter(&sis5595_adapter);
+       release_region(sis5595_base + SMB_INDEX, 2);
+}
+
+
+static struct pci_driver sis5595_driver = {
+       .name           = "sis5595 smbus",
+       .id_table       = sis5595_ids,
+       .probe          = sis5595_probe,
+       .remove         = __devexit_p(sis5595_remove),
+};
+
+static int __init i2c_sis5595_init(void)
+{
+       printk("i2c-sis5595.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       return pci_module_init(&sis5595_driver);
+}
+
+
+static void __exit i2c_sis5595_exit(void)
+{
+       pci_unregister_driver(&sis5595_driver);
+}
+
+
+
+MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
+MODULE_DESCRIPTION("SIS5595 SMBus driver");
+
+module_init(i2c_sis5595_init);
+module_exit(i2c_sis5595_exit);
--- linux-old/drivers/i2c/i2c-sis630.c  Thu Jan  1 00:00:00 1970
+++ linux/drivers/i2c/i2c-sis630.c      Mon Dec 13 20:18:42 2004
@@ -0,0 +1,527 @@
+/*
+    i2c-sis630.c - Part of lm_sensors, Linux kernel modules for hardware
+              monitoring
+
+    Copyright (c) 2002,2003 Alexander Malysh <amalysh@web.de>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+   Changes:
+   24.08.2002
+       Fixed the typo in sis630_access (Thanks to Mark M. Hoffman)
+       Changed sis630_transaction.(Thanks to Mark M. Hoffman)
+   18.09.2002
+       Added SIS730 as supported.
+   21.09.2002
+       Added high_clock module option.If this option is set
+       used Host Master Clock 56KHz (default 14KHz).For now we save old Host
+       Master Clock and after transaction completed restore (otherwise
+       it's confuse BIOS and hung Machine).
+   24.09.2002
+       Fixed typo in sis630_access
+       Fixed logical error by restoring of Host Master Clock
+   31.07.2003
+       Added block data read/write support.
+*/
+
+/*
+   Status: beta
+
+   Supports:
+       SIS 630
+       SIS 730
+
+   Note: we assume there can only be one device, with one SMBus interface.
+*/
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/pci.h>
+#include <linux/stddef.h>
+#include <linux/sched.h>
+#include <linux/ioport.h>
+#include <linux/i2c.h>
+#include <linux/init.h>
+#include <asm/io.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+
+#ifdef DEBUG
+#define DBG(x...) printk(KERN_DEBUG "i2c-sis630.o: " x)
+#else
+#define DBG(x...)
+#endif
+
+/* SIS630 SMBus registers */
+#define SMB_STS     0x80 /* status */
+#define SMB_EN      0x81 /* status enable */
+#define SMB_CNT     0x82
+#define SMBHOST_CNT 0x83
+#define SMB_ADDR    0x84
+#define SMB_CMD     0x85
+#define SMB_PCOUNT  0x86 /* processed count */
+#define SMB_COUNT   0x87
+#define SMB_BYTE    0x88 /* ~0x8F data byte field */
+#define SMBDEV_ADDR 0x90
+#define SMB_DB0     0x91
+#define SMB_DB1     0x92
+#define SMB_SAA     0x93
+
+/* register count for request_region */
+#define SIS630_SMB_IOREGION 20
+
+/* PCI address constants */
+/* acpi base address register  */
+#define SIS630_ACPI_BASE_REG 0x74
+/* bios control register */
+#define SIS630_BIOS_CTL_REG  0x40
+
+/* Other settings */
+#define MAX_TIMEOUT   500
+
+/* SIS630 constants */
+#define SIS630_QUICK      0x00
+#define SIS630_BYTE       0x01
+#define SIS630_BYTE_DATA  0x02
+#define SIS630_WORD_DATA  0x03
+#define SIS630_PCALL      0x04
+#define SIS630_BLOCK_DATA 0x05
+
+/* insmod parameters */
+static int high_clock = 0;
+static int force = 0;
+MODULE_PARM(high_clock, "i");
+MODULE_PARM_DESC(high_clock, "Set Host Master Clock to 56KHz (default 14KHz).");
+MODULE_PARM(force, "i");
+MODULE_PARM_DESC(force, "Forcibly enable the SIS630. DANGEROUS!");
+
+/* acpi base address */
+static unsigned short acpi_base = 0;
+
+/* supported chips */
+static int supported[] = {
+       PCI_DEVICE_ID_SI_630,
+       PCI_DEVICE_ID_SI_730,
+       0 /* terminates the list */
+};
+
+static inline u8 sis630_read(u8 reg) {
+       return inb(acpi_base + reg);
+}
+
+static inline void sis630_write(u8 reg, u8 data) {
+       outb(data, acpi_base + reg);
+}
+
+static int sis630_transaction_start(int size, u8 *oldclock) {
+        int temp;
+
+        /*
+         Make sure the SMBus host is ready to start transmitting.
+       */
+       if ((temp = sis630_read(SMB_CNT) & 0x03) != 0x00) {
+                DBG("SMBus busy (%02x).Resetting...\n",temp);
+               /* kill smbus transaction */
+               sis630_write(SMBHOST_CNT, 0x20);
+
+               if ((temp = sis630_read(SMB_CNT) & 0x03) != 0x00) {
+                        DBG("Failed! (%02x)\n", temp);
+                       return -1;
+                } else {
+                        DBG("Successfull!\n");
+               }
+        }
+
+       /* save old clock, so we can prevent machine for hung */
+       *oldclock = sis630_read(SMB_CNT);
+
+       DBG("saved clock 0x%02x\n", *oldclock);
+
+       /* disable timeout interrupt , set Host Master Clock to 56KHz if requested */
+       if (high_clock > 0)
+               sis630_write(SMB_CNT, 0x20);
+       else
+               sis630_write(SMB_CNT, (*oldclock & ~0x40));
+
+       /* clear all sticky bits */
+       temp = sis630_read(SMB_STS);
+       sis630_write(SMB_STS, temp & 0x1e);
+
+       /* start the transaction by setting bit 4 and size */
+       sis630_write(SMBHOST_CNT,0x10 | (size & 0x07));
+
+       return 0;
+}
+
+static int sis630_transaction_wait(int size) {
+        int temp, result = 0, timeout = 0;
+
+        /* We will always wait for a fraction of a second! */
+        do {
+                i2c_delay(1);
+                temp = sis630_read(SMB_STS);
+               /* check if block transmitted */
+               if (size == SIS630_BLOCK_DATA && (temp & 0x10))
+                   break;
+        } while (!(temp & 0x0e) && (timeout++ < MAX_TIMEOUT));
+
+        /* If the SMBus is still busy, we give up */
+        if (timeout >= MAX_TIMEOUT) {
+                DBG("SMBus Timeout!\n");
+               result = -1;
+        }
+
+        if (temp & 0x02) {
+                result = -1;
+                DBG("Error: Failed bus transaction\n");
+       }
+
+        if (temp & 0x04) {
+                result = -1;
+                printk(KERN_ERR "i2c-sis630.o: Bus collision!\n");
+               /*
+                  TBD: Datasheet say:
+                       the software should clear this bit and restart SMBUS operation.
+                       Should we do it or user start request again?
+               */
+        }
+
+       return result;
+}
+
+static void sis630_transaction_end(u8 oldclock) {
+        int temp = 0;
+
+        /* clear all status "sticky" bits */
+       sis630_write(SMB_STS, temp);
+
+       DBG("SMB_CNT before clock restore 0x%02x\n", sis630_read(SMB_CNT));
+
+       /*
+       * restore old Host Master Clock if high_clock is set
+       * and oldclock was not 56KHz
+       */
+       if (high_clock > 0 && !(oldclock & 0x20))
+               sis630_write(SMB_CNT,(sis630_read(SMB_CNT) & ~0x20));
+
+       DBG("SMB_CNT after clock restore 0x%02x\n", sis630_read(SMB_CNT));
+}
+
+static int sis630_transaction(int size) {
+        int result = 0;
+       u8 oldclock = 0;
+
+       if (!(result = sis630_transaction_start(size, &oldclock))) {
+               result = sis630_transaction_wait(size);
+               sis630_transaction_end(oldclock);
+       }
+
+        return result;
+}
+
+static int sis630_block_data(union i2c_smbus_data * data, int read_write) {
+       int i, len = 0, rc = 0;
+       u8 oldclock = 0;
+
+       if (read_write == I2C_SMBUS_WRITE) {
+               len = data->block[0];
+               if (len < 0)
+                       len = 0;
+               else if (len > 32)
+                       len = 32;
+               sis630_write(SMB_COUNT, len);
+               for (i=1; i <= len; i++) {
+                       DBG("set data 0x%02x\n", data->block[i]);
+                       /* set data */
+                       sis630_write(SMB_BYTE+(i-1)%8, data->block[i]);
+                       if (i==8 || (len<8 && i==len)) {
+                               DBG("start trans len=%d i=%d\n",len ,i);
+                               /* first transaction */
+                               if (sis630_transaction_start(SIS630_BLOCK_DATA, &oldclock))
+                                       return -1;
+                       }
+                       else if ((i-1)%8 == 7 || i==len) {
+                               DBG("trans_wait len=%d i=%d\n",len,i);
+                               if (i>8) {
+                                       DBG("clear smbary_sts len=%d i=%d\n",len,i);
+                                       /*
+                                          If this is not first transaction,
+                                          we must clear sticky bit.
+                                          clear SMBARY_STS
+                                       */
+                                       sis630_write(SMB_STS,0x10);
+                               }
+                               if (sis630_transaction_wait(SIS630_BLOCK_DATA)) {
+                                       DBG("trans_wait failed\n");
+                                       rc = -1;
+                                       break;
+                               }
+
+                       }
+               }
+       }
+       else { /* read request */
+               data->block[0] = len = 0;
+               if (sis630_transaction_start(SIS630_BLOCK_DATA, &oldclock)) {
+                       return -1;
+               }
+               do {
+                       if (sis630_transaction_wait(SIS630_BLOCK_DATA)) {
+                               DBG("trans_wait failed\n");
+                               rc = -1;
+                               break;
+                       }
+                       /* if this first transaction then read byte count */
+                       if (len == 0)
+                               data->block[0] = sis630_read(SMB_COUNT);
+
+                       /* just to be sure */
+                       if (data->block[0] > 32)
+                               data->block[0] = 32;
+
+                       DBG("block data read len=0x%x\n", data->block[0]);
+
+                       for (i=0; i < 8 && len < data->block[0]; i++,len++) {
+                               DBG("read i=%d len=%d\n", i, len);
+                               data->block[len+1] = sis630_read(SMB_BYTE+i);
+                       }
+
+                       DBG("clear smbary_sts len=%d i=%d\n",len,i);
+
+                       /* clear SMBARY_STS */
+                       sis630_write(SMB_STS,0x10);
+               } while(len < data->block[0]);
+       }
+
+       sis630_transaction_end(oldclock);
+
+       return rc;
+}
+
+/* Return -1 on error. */
+static s32 sis630_access(struct i2c_adapter * adap, u16 addr,
+                  unsigned short flags, char read_write,
+                  u8 command, int size, union i2c_smbus_data * data)
+{
+
+       switch (size) {
+               case I2C_SMBUS_QUICK:
+                       sis630_write(SMB_ADDR, ((addr & 0x7f) << 1) | (read_write & 0x01));
+                       size = SIS630_QUICK;
+                       break;
+               case I2C_SMBUS_BYTE:
+                       sis630_write(SMB_ADDR, ((addr & 0x7f) << 1) | (read_write & 0x01));
+                       if (read_write == I2C_SMBUS_WRITE)
+                               sis630_write(SMB_CMD, command);
+                       size = SIS630_BYTE;
+                       break;
+               case I2C_SMBUS_BYTE_DATA:
+                       sis630_write(SMB_ADDR, ((addr & 0x7f) << 1) | (read_write & 0x01));
+                       sis630_write(SMB_CMD, command);
+                       if (read_write == I2C_SMBUS_WRITE)
+                               sis630_write(SMB_BYTE, data->byte);
+                       size = SIS630_BYTE_DATA;
+                       break;
+               case I2C_SMBUS_PROC_CALL:
+               case I2C_SMBUS_WORD_DATA:
+                       sis630_write(SMB_ADDR,((addr & 0x7f) << 1) | (read_write & 0x01));
+                       sis630_write(SMB_CMD, command);
+                       if (read_write == I2C_SMBUS_WRITE) {
+                               sis630_write(SMB_BYTE, data->word & 0xff);
+                               sis630_write(SMB_BYTE + 1,(data->word & 0xff00) >> 8);
+                       }
+                       size = (size == I2C_SMBUS_PROC_CALL ? SIS630_PCALL : SIS630_WORD_DATA);
+                       break;
+               case I2C_SMBUS_BLOCK_DATA:
+                       sis630_write(SMB_ADDR,((addr & 0x7f) << 1) | (read_write & 0x01));
+                       sis630_write(SMB_CMD, command);
+                       size = SIS630_BLOCK_DATA;
+                       return sis630_block_data(data, read_write);
+               default:
+                       printk("Unsupported I2C size\n");
+                       return -1;
+                       break;
+       }
+
+
+       if (sis630_transaction(size))
+               return -1;
+
+        if ((size != SIS630_PCALL) &&
+               ((read_write == I2C_SMBUS_WRITE) || (size == SIS630_QUICK))) {
+                return 0;
+       }
+
+       switch(size) {
+               case SIS630_BYTE:
+               case SIS630_BYTE_DATA:
+                       data->byte = sis630_read(SMB_BYTE);
+                       break;
+               case SIS630_PCALL:
+               case SIS630_WORD_DATA:
+                       data->word = sis630_read(SMB_BYTE) + (sis630_read(SMB_BYTE + 1) << 8);
+                       break;
+               default:
+                       return -1;
+                       break;
+       }
+
+       return 0;
+}
+
+
+static u32 sis630_func(struct i2c_adapter *adapter) {
+       return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE | I2C_FUNC_SMBUS_BYTE_DATA |
+               I2C_FUNC_SMBUS_WORD_DATA | I2C_FUNC_SMBUS_PROC_CALL |
+               I2C_FUNC_SMBUS_BLOCK_DATA;
+}
+
+static int __devinit sis630_setup(struct pci_dev *sis630_dev) {
+       unsigned char b;
+       struct pci_dev *dummy = NULL;
+       int i;
+
+       /* check for supported SiS devices */
+       for (i=0; supported[i] > 0; i++) {
+               if ((dummy = pci_find_device(PCI_VENDOR_ID_SI, supported[i], dummy)))
+                       break; /* found */
+       }
+
+       if (!dummy && force > 0) {
+               printk(KERN_ERR "i2c-sis630.o: WARNING: Can't detect SIS630 compatible device, but "
+                       "loading because of force option enabled\n");
+       }
+       else if (!dummy) {
+               return -ENODEV;
+       }
+
+       /*
+          Enable ACPI first , so we can accsess reg 74-75
+          in acpi io space and read acpi base addr
+       */
+       if (PCIBIOS_SUCCESSFUL !=
+           pci_read_config_byte(sis630_dev, SIS630_BIOS_CTL_REG,&b)) {
+               printk(KERN_ERR "i2c-sis630.o: Error: Can't read bios ctl reg\n");
+               return -ENODEV;
+       }
+
+       /* if ACPI already enabled , do nothing */
+       if (!(b & 0x80) &&
+           PCIBIOS_SUCCESSFUL !=
+           pci_write_config_byte(sis630_dev,SIS630_BIOS_CTL_REG,b|0x80)) {
+               printk(KERN_ERR "i2c-sis630.o: Error: Can't enable ACPI\n");
+               return -ENODEV;
+       }
+       /* Determine the ACPI base address */
+       if (PCIBIOS_SUCCESSFUL !=
+           pci_read_config_word(sis630_dev,SIS630_ACPI_BASE_REG,&acpi_base)) {
+               printk(KERN_ERR "i2c-sis630.o: Error: Can't determine ACPI base address\n");
+               return -ENODEV;
+       }
+
+       DBG("ACPI base at 0x%04x\n", acpi_base);
+
+       /* Everything is happy, let's grab the memory and set things up. */
+       if (!request_region(acpi_base + SMB_STS, SIS630_SMB_IOREGION, "sis630-smbus")){
+               printk(KERN_ERR "i2c-sis630.o: SMBus registers 0x%04x-0x%04x "
+                       "already in use!\n",acpi_base + SMB_STS, acpi_base + SMB_SAA);
+               acpi_base = 0; /* reset acpi_base */
+               return -ENODEV;
+       }
+
+       return 0;
+}
+
+
+static struct i2c_algorithm smbus_algorithm = {
+       .name           = "Non-I2C SMBus adapter",
+       .id             = I2C_ALGO_SMBUS,
+       .smbus_xfer     = sis630_access,
+       .functionality  = sis630_func,
+};
+
+static struct i2c_adapter sis630_adapter = {
+       .owner          = THIS_MODULE,
+       .name           = "unset",
+       .id             = I2C_ALGO_SMBUS | I2C_HW_SMBUS_SIS630,
+       .algo           = &smbus_algorithm,
+};
+
+
+static struct pci_device_id sis630_ids[] __devinitdata = {
+       {
+               .vendor =       PCI_VENDOR_ID_SI,
+               .device =       PCI_DEVICE_ID_SI_503,
+               .subvendor =    PCI_ANY_ID,
+               .subdevice =    PCI_ANY_ID,
+       },
+       { 0, }
+};
+
+static int __devinit sis630_probe(struct pci_dev *dev, const struct pci_device_id *id)
+{
+       if (sis630_setup(dev)) {
+               printk(KERN_ERR "i2c-sis630.o: SIS630 comp. bus not detected, module not inserted.\n");
+               return -ENODEV;
+       }
+
+       sprintf(sis630_adapter.name, "SMBus SIS630 adapter at %04x",
+               acpi_base + SMB_STS);
+
+       return i2c_add_adapter(&sis630_adapter);
+}
+
+static void __devexit sis630_remove(struct pci_dev *dev)
+{
+       if (acpi_base) {
+               i2c_del_adapter(&sis630_adapter);
+               release_region(acpi_base + SMB_STS, SIS630_SMB_IOREGION);
+               acpi_base = 0;
+       }
+}
+
+
+static struct pci_driver sis630_driver = {
+       .name           = "sis630 smbus",
+       .id_table       = sis630_ids,
+       .probe          = sis630_probe,
+       .remove         = __devexit_p(sis630_remove),
+};
+
+static int __init i2c_sis630_init(void)
+{
+       printk("i2c-sis630.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       return pci_module_init(&sis630_driver);
+}
+
+
+static void __exit i2c_sis630_exit(void)
+{
+       pci_unregister_driver(&sis630_driver);
+}
+
+
+
+
+MODULE_LICENSE("GPL");
+
+MODULE_AUTHOR("Alexander Malysh <amalysh@web.de>");
+MODULE_DESCRIPTION("SIS630 SMBus driver");
+
+module_init(i2c_sis630_init);
+module_exit(i2c_sis630_exit);
--- linux-old/drivers/i2c/i2c-sis645.c  Thu Jan  1 00:00:00 1970
+++ linux/drivers/i2c/i2c-sis645.c      Mon Dec 13 20:18:42 2004
@@ -0,0 +1,590 @@
+/*
+    sis645.c - Part of lm_sensors, Linux kernel modules for hardware
+              monitoring
+
+    Copyright (c) 2003 Mark M. Hoffman <mhoffman@lightlink.com>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+    This module must be considered BETA unless and until
+    the chipset manufacturer releases a datasheet.
+
+    The register definitions are based on the SiS630.
+    The method for *finding* the registers is based on trial and error.
+
+    A history of changes to this file is available by anonymous CVS:
+    http://www2.lm-sensors.nu/~lm78/download.html
+*/
+
+/*   25th March 2004
+     Support for Sis655 chipsets added by Ken Healy
+*/
+
+/*
+    Note: we assume there can only be one SiS645 with one SMBus interface
+*/
+
+/* #define DEBUG 1 */
+
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/kernel.h>
+#include <linux/stddef.h>
+#include <linux/sched.h>
+#include <linux/ioport.h>
+#include <linux/i2c.h>
+#include <linux/init.h>
+#include <linux/mm.h>
+#include <asm/io.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+#include <linux/sensors_compat.h>
+
+#define DRV_NAME "i2c-sis645"
+
+/* SiS645DX north bridge (defined in 2.4.21) */
+#ifndef PCI_DEVICE_ID_SI_646
+#define PCI_DEVICE_ID_SI_646 0x0646
+#endif
+
+/* SiS648 north bridge (defined in 2.4.21) */
+#ifndef PCI_DEVICE_ID_SI_648
+#define PCI_DEVICE_ID_SI_648 0x0648
+#endif
+
+/* SiS650 north bridge (defined in 2.4.19) */
+#ifndef PCI_DEVICE_ID_SI_650
+#define PCI_DEVICE_ID_SI_650 0x0650
+#endif
+
+/* SiS651 north bridge (defined in 2.4.21)*/
+#ifndef PCI_DEVICE_ID_SI_651
+#define PCI_DEVICE_ID_SI_651 0x0651
+#endif
+
+/* SiS655 north bridge (defined in 2.4.22)*/
+#ifndef PCI_DEVICE_ID_SI_655
+#define PCI_DEVICE_ID_SI_655 0x0655
+#endif
+
+/* SiS746 north bridge (defined in 2.4.21) */
+#ifndef PCI_DEVICE_ID_SI_746
+#define PCI_DEVICE_ID_SI_746 0x0746
+#endif
+
+/* SiS85C503/5513 (LPC Bridge) */
+#ifndef PCI_DEVICE_ID_SI_LPC
+#define PCI_DEVICE_ID_SI_LPC 0x0018
+#endif
+
+/* SiS961 south bridge */
+#ifndef PCI_DEVICE_ID_SI_961
+#define PCI_DEVICE_ID_SI_961 0x0961
+#endif
+
+/* SiS962 south bridge */
+#ifndef PCI_DEVICE_ID_SI_962
+#define PCI_DEVICE_ID_SI_962 0x0962
+#endif
+
+/* SiS963 south bridge */
+#ifndef PCI_DEVICE_ID_SI_963
+#define PCI_DEVICE_ID_SI_963 0x0963
+#endif
+
+/* SMBus ID */
+#ifndef PCI_DEVICE_ID_SI_SMBUS
+#define PCI_DEVICE_ID_SI_SMBUS 0x16
+#endif
+
+/* base address register in PCI config space */
+#define SIS645_BAR 0x04
+
+/* SiS645 SMBus registers */
+#define SMB_STS      0x00
+#define SMB_EN       0x01
+#define SMB_CNT      0x02
+#define SMB_HOST_CNT 0x03
+#define SMB_ADDR     0x04
+#define SMB_CMD      0x05
+#define SMB_PCOUNT   0x06
+#define SMB_COUNT    0x07
+#define SMB_BYTE     0x08
+#define SMB_DEV_ADDR 0x10
+#define SMB_DB0      0x11
+#define SMB_DB1      0x12
+#define SMB_SAA      0x13
+
+/* register count for request_region */
+#define SMB_IOSIZE 0x20
+
+/* Other settings */
+#define MAX_TIMEOUT 500
+
+/* SiS645 SMBus constants */
+#define SIS645_QUICK      0x00
+#define SIS645_BYTE       0x01
+#define SIS645_BYTE_DATA  0x02
+#define SIS645_WORD_DATA  0x03
+#define SIS645_PROC_CALL  0x04
+#define SIS645_BLOCK_DATA 0x05
+
+static struct i2c_adapter sis645_adapter;
+static u16 sis645_smbus_base = 0;
+
+static inline u8 sis645_read(u8 reg)
+{
+       return inb(sis645_smbus_base + reg) ;
+}
+
+static inline void sis645_write(u8 reg, u8 data)
+{
+       outb(data, sis645_smbus_base + reg) ;
+}
+
+#ifdef CONFIG_HOTPLUG
+
+/* Turns on SMBus device if it is not; return 0 iff successful
+ */
+static int __devinit sis645_enable_smbus(struct pci_dev *dev)
+{
+       u8 val = 0;
+
+       pci_read_config_byte(dev, 0x77, &val);
+
+#ifdef DEBUG
+       printk(KERN_DEBUG DRV_NAME ": Config byte was 0x%02x.\n", val);
+#endif
+
+       pci_write_config_byte(dev, 0x77, val & ~0x10);
+
+       pci_read_config_byte(dev, 0x77, &val);
+
+       if (val & 0x10) {
+#ifdef DEBUG
+               printk(KERN_DEBUG DRV_NAME ": Config byte stuck!\n");
+#endif
+               return -1;
+       }
+
+       return 0;
+}
+
+/* Builds the basic pci_dev for SiS645 SMBus
+ */
+static int __devinit sis645_build_dev(struct pci_dev **smbus_dev,
+                           struct pci_dev *bridge_dev)
+{
+       struct pci_dev temp_dev;
+       u16 vid = 0, did = 0;
+       int ret;
+
+       /* fill in the device structure for search */
+       memset(&temp_dev, 0, sizeof(temp_dev));
+       temp_dev.bus = bridge_dev->bus;
+       temp_dev.sysdata = bridge_dev->bus->sysdata;
+       temp_dev.hdr_type = PCI_HEADER_TYPE_NORMAL;
+
+       /* the SMBus device is function 1 on the same unit as the ISA bridge */
+       temp_dev.devfn = bridge_dev->devfn + 1;
+
+       /* query to make sure */
+       ret = pci_read_config_word(&temp_dev, PCI_VENDOR_ID, &vid);
+       if (ret || PCI_VENDOR_ID_SI != vid) {
+               printk(KERN_ERR DRV_NAME ": Couldn't find SMBus device!\n");
+               return ret;
+       }
+       temp_dev.vendor = vid;
+
+       ret = pci_read_config_word(&temp_dev, PCI_DEVICE_ID, &did);
+       if (ret || PCI_DEVICE_ID_SI_SMBUS != did) {
+               printk(KERN_ERR DRV_NAME ": Couldn't find SMBus device!\n");
+               return ret;
+       }
+       temp_dev.device = did;
+
+       /* ok, we've got it... request some memory and finish it off */
+       *smbus_dev = kmalloc(sizeof(**smbus_dev), GFP_ATOMIC);
+       if (NULL == *smbus_dev) {
+               printk(KERN_ERR DRV_NAME ": Out of memory!\n");
+               return -ENOMEM;
+       }
+
+       **smbus_dev = temp_dev;
+       
+       ret = pci_setup_device(*smbus_dev);
+       if (ret) {
+               printk(KERN_ERR DRV_NAME ": pci_setup_device failed (0x%08x)\n",ret);
+       }
+       return ret;
+}
+
+/* See if a SMBus can be found, and enable it if possible.
+ */
+static int __devinit sis645_hotplug_smbus(void)
+{
+       int ret;
+       struct pci_dev *smbus_dev, *bridge_dev ;
+
+       if ((bridge_dev = pci_find_device(PCI_VENDOR_ID_SI,
+                       PCI_DEVICE_ID_SI_961, NULL)))
+               printk(KERN_INFO DRV_NAME ": Found SiS961 south bridge.\n");
+
+       else if ((bridge_dev = pci_find_device(PCI_VENDOR_ID_SI,
+                       PCI_DEVICE_ID_SI_962, NULL)))
+               printk(KERN_INFO DRV_NAME ": Found SiS962 [MuTIOL Media IO].\n");
+
+       else if ((bridge_dev = pci_find_device(PCI_VENDOR_ID_SI,
+                       PCI_DEVICE_ID_SI_963, NULL)))
+               printk(KERN_INFO DRV_NAME ": Found SiS963 [MuTIOL Media IO].\n");
+               
+       else if ((bridge_dev = pci_find_device(PCI_VENDOR_ID_SI,
+                       PCI_DEVICE_ID_SI_503, NULL)) ||
+               (bridge_dev = pci_find_device(PCI_VENDOR_ID_SI,
+                       PCI_DEVICE_ID_SI_LPC, NULL))) {
+
+               printk(KERN_INFO DRV_NAME ": Found SiS south bridge in compatability mode(?)\n");
+
+               /* look for known compatible north bridges */
+               if ((NULL == pci_find_device(PCI_VENDOR_ID_SI, 
+                               PCI_DEVICE_ID_SI_645, NULL))
+                       && (NULL == pci_find_device(PCI_VENDOR_ID_SI,
+                               PCI_DEVICE_ID_SI_646, NULL))
+                       && (NULL == pci_find_device(PCI_VENDOR_ID_SI,
+                               PCI_DEVICE_ID_SI_648, NULL))
+                       && (NULL == pci_find_device(PCI_VENDOR_ID_SI,
+                               PCI_DEVICE_ID_SI_650, NULL))
+                       && (NULL == pci_find_device(PCI_VENDOR_ID_SI,
+                               PCI_DEVICE_ID_SI_651, NULL))
+                       && (NULL == pci_find_device(PCI_VENDOR_ID_SI,
+                               PCI_DEVICE_ID_SI_655, NULL))
+                       && (NULL == pci_find_device(PCI_VENDOR_ID_SI,
+                               PCI_DEVICE_ID_SI_735, NULL))
+                       && (NULL == pci_find_device(PCI_VENDOR_ID_SI,
+                               PCI_DEVICE_ID_SI_745, NULL))
+                       && (NULL == pci_find_device(PCI_VENDOR_ID_SI,
+                               PCI_DEVICE_ID_SI_746, NULL))) {
+                       printk(KERN_ERR DRV_NAME ": Can't find suitable host bridge!\n");
+                       return -ENODEV;
+               }
+       } else {
+               printk(KERN_ERR DRV_NAME ": Can't find suitable south bridge!\n");
+               return -ENODEV;
+       }
+
+       /* if we get this far, we think the smbus device is present */
+
+       if ((ret = sis645_enable_smbus(bridge_dev)))
+               return ret;
+
+       if ((ret = sis645_build_dev(&smbus_dev, bridge_dev)))
+               return ret;
+
+       if ((ret = pci_enable_device(smbus_dev))) {
+               printk(KERN_ERR DRV_NAME ": Can't pci_enable SMBus device!"
+                       " (0x%08x)\n", ret);
+               return ret;
+       }
+
+       pci_insert_device(smbus_dev, smbus_dev->bus);
+
+       return 0;
+}
+#endif /* CONFIG_HOTPLUG */
+
+/* Execute a SMBus transaction.
+   int size is from SIS645_QUICK to SIS645_BLOCK_DATA
+ */
+static int sis645_transaction(int size)
+{
+       int temp;
+       int result = 0;
+       int timeout = 0;
+
+       /* Make sure the SMBus host is ready to start transmitting */
+       if (((temp = sis645_read(SMB_CNT)) & 0x03) != 0x00) {
+#ifdef DEBUG
+               printk(KERN_DEBUG DRV_NAME ": SMBus busy (0x%02x). Resetting...\n",
+                               temp);
+#endif
+
+               /* kill the transaction */
+               sis645_write(SMB_HOST_CNT, 0x20);
+
+               /* check it again */
+               if (((temp = sis645_read(SMB_CNT)) & 0x03) != 0x00) {
+#ifdef DEBUG
+                       printk(KERN_DEBUG DRV_NAME ": Failed! (0x%02x)\n", temp);
+#endif
+                       return -1;
+               } else {
+#ifdef DEBUG
+                       printk(KERN_DEBUG DRV_NAME ": Successful!\n");
+#endif
+               }
+       }
+
+       /* Turn off timeout interrupts, set fast host clock */
+       sis645_write(SMB_CNT, 0x20);
+
+       /* clear all (sticky) status flags */
+       temp = sis645_read(SMB_STS);
+       sis645_write(SMB_STS, temp & 0x1e);
+
+       /* start the transaction by setting bit 4 and size bits */
+       sis645_write(SMB_HOST_CNT, 0x10 | (size & 0x07));
+
+       /* We will always wait for a fraction of a second! */
+       do {
+               i2c_delay(1);
+               temp = sis645_read(SMB_STS);
+       } while (!(temp & 0x0e) && (timeout++ < MAX_TIMEOUT));
+
+       /* If the SMBus is still busy, we give up */
+       if (timeout >= MAX_TIMEOUT) {
+               printk(KERN_DEBUG DRV_NAME ": SMBus Timeout! (0x%02x)\n",temp);
+               result = -1;
+       }
+
+       /* device error - probably missing ACK */
+       if (temp & 0x02) {
+#ifdef DEBUG
+               printk(KERN_DEBUG DRV_NAME ": Failed bus transaction!\n");
+#endif
+               result = -1;
+       }
+
+       /* bus collision */
+       if (temp & 0x04) {
+#ifdef DEBUG
+               printk(KERN_DEBUG DRV_NAME ": Bus collision!\n");
+#endif
+               result = -1;
+       }
+
+       /* Finish up by resetting the bus */
+       sis645_write(SMB_STS, temp);
+       if ((temp = sis645_read(SMB_STS))) {
+#ifdef DEBUG
+               printk(KERN_DEBUG DRV_NAME ": Failed reset at end of transaction!"
+                               " (0x%02x)\n", temp);
+#endif
+       }
+
+       return result;
+}
+
+/* Return -1 on error. */
+static s32 sis645_access(struct i2c_adapter * adap, u16 addr,
+                  unsigned short flags, char read_write,
+                  u8 command, int size, union i2c_smbus_data * data)
+{
+
+       switch (size) {
+       case I2C_SMBUS_QUICK:
+               sis645_write(SMB_ADDR, ((addr & 0x7f) << 1) | (read_write & 0x01));
+               size = SIS645_QUICK;
+               break;
+
+       case I2C_SMBUS_BYTE:
+               sis645_write(SMB_ADDR, ((addr & 0x7f) << 1) | (read_write & 0x01));
+               if (read_write == I2C_SMBUS_WRITE)
+                       sis645_write(SMB_CMD, command);
+               size = SIS645_BYTE;
+               break;
+
+       case I2C_SMBUS_BYTE_DATA:
+               sis645_write(SMB_ADDR, ((addr & 0x7f) << 1) | (read_write & 0x01));
+               sis645_write(SMB_CMD, command);
+               if (read_write == I2C_SMBUS_WRITE)
+                       sis645_write(SMB_BYTE, data->byte);
+               size = SIS645_BYTE_DATA;
+               break;
+
+       case I2C_SMBUS_PROC_CALL:
+       case I2C_SMBUS_WORD_DATA:
+               sis645_write(SMB_ADDR, ((addr & 0x7f) << 1) | (read_write & 0x01));
+               sis645_write(SMB_CMD, command);
+               if (read_write == I2C_SMBUS_WRITE) {
+                       sis645_write(SMB_BYTE, data->word & 0xff);
+                       sis645_write(SMB_BYTE + 1, (data->word & 0xff00) >> 8);
+               }
+               size = (size == I2C_SMBUS_PROC_CALL ? SIS645_PROC_CALL : SIS645_WORD_DATA);
+               break;
+
+       case I2C_SMBUS_BLOCK_DATA:
+               /* TO DO: */
+               printk(KERN_INFO DRV_NAME ": SMBus block not implemented!\n");
+               return -1;
+               break;
+
+       default:
+               printk(KERN_INFO DRV_NAME ": Unsupported I2C size\n");
+               return -1;
+               break;
+       }
+
+       if (sis645_transaction(size))
+               return -1;
+
+       if ((size != SIS645_PROC_CALL) &&
+                       ((read_write == I2C_SMBUS_WRITE) || (size == SIS645_QUICK)))
+               return 0;
+
+       switch (size) {
+       case SIS645_BYTE:
+       case SIS645_BYTE_DATA:
+               data->byte = sis645_read(SMB_BYTE);
+               break;
+
+       case SIS645_WORD_DATA:
+       case SIS645_PROC_CALL:
+               data->word = sis645_read(SMB_BYTE) +
+                               (sis645_read(SMB_BYTE + 1) << 8);
+               break;
+       }
+       return 0;
+}
+
+static u32 sis645_func(struct i2c_adapter *adapter)
+{
+       return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
+           I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
+           I2C_FUNC_SMBUS_PROC_CALL;
+}
+
+static struct i2c_algorithm smbus_algorithm = {
+       .name           = "Non-I2C SMBus adapter",
+       .id             = I2C_ALGO_SMBUS,
+       .smbus_xfer     = sis645_access,
+       .functionality  = sis645_func,
+};
+
+static struct i2c_adapter sis645_adapter = {
+       .owner          = THIS_MODULE,
+       .name           = "unset",
+       .id             = I2C_ALGO_SMBUS | I2C_HW_SMBUS_SIS645,
+       .algo           = &smbus_algorithm,
+};
+
+static struct pci_device_id sis645_ids[] __devinitdata = {
+       {
+               .vendor = PCI_VENDOR_ID_SI,
+               .device = PCI_DEVICE_ID_SI_SMBUS,
+               .subvendor = PCI_ANY_ID,
+               .subdevice = PCI_ANY_ID,
+       },
+       { 0, }
+};
+
+static int __devinit sis645_probe(struct pci_dev *dev,
+                               const struct pci_device_id *id)
+{
+       u16 ww = 0;
+       int retval;
+
+       if (sis645_smbus_base) {
+               dev_err(dev, "Only one device supported.\n");
+               return -EBUSY;
+       }
+
+       pci_read_config_word(dev, PCI_CLASS_DEVICE, &ww);
+       if (PCI_CLASS_SERIAL_SMBUS != ww) {
+               dev_err(dev, "Unsupported device class 0x%04x!\n", ww);
+               return -ENODEV;
+       }
+
+       sis645_smbus_base = pci_resource_start(dev, SIS645_BAR);
+       if (!sis645_smbus_base) {
+               dev_err(dev, "SiS645 SMBus base address "
+                       "not initialized!\n");
+               return -EINVAL;
+       }
+       dev_info(dev, "SiS645 SMBus base address: 0x%04x\n",
+                       sis645_smbus_base);
+
+       /* Everything is happy, let's grab the memory and set things up. */
+       if (!request_region(sis645_smbus_base, SMB_IOSIZE, "sis645-smbus")) {
+               dev_err(dev, "SMBus registers 0x%04x-0x%04x "
+                       "already in use!\n", sis645_smbus_base,
+                       sis645_smbus_base + SMB_IOSIZE - 1);
+
+               sis645_smbus_base = 0;
+               return -EINVAL;
+       }
+
+       sprintf(sis645_adapter.name, "SiS645 SMBus adapter at 0x%04x",
+                       sis645_smbus_base);
+
+       if ((retval = i2c_add_adapter(&sis645_adapter))) {
+               dev_err(dev, "Couldn't register adapter!\n");
+               release_region(sis645_smbus_base, SMB_IOSIZE);
+               sis645_smbus_base = 0;
+       }
+
+       return retval;
+}
+
+static void __devexit sis645_remove(struct pci_dev *dev)
+{
+       if (sis645_smbus_base) {
+               i2c_del_adapter(&sis645_adapter);
+               release_region(sis645_smbus_base, SMB_IOSIZE);
+               sis645_smbus_base = 0;
+       }
+}
+
+static struct pci_driver sis645_driver = {
+       .name           = "sis645 smbus",
+       .id_table       = sis645_ids,
+       .probe          = sis645_probe,
+       .remove         = __devexit_p(sis645_remove),
+};
+
+static int __init i2c_sis645_init(void)
+{
+       printk(KERN_INFO DRV_NAME ".o version %s (%s)\n", LM_VERSION, LM_DATE);
+
+       /* if the required device id is not present, try to HOTPLUG it first */
+       if (!pci_find_device(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_SMBUS, NULL)) {
+
+               printk(KERN_INFO DRV_NAME ": "
+                       "Attempting to enable SiS645 SMBus device\n");
+
+#ifdef CONFIG_HOTPLUG
+               sis645_hotplug_smbus();
+#else
+               printk(KERN_INFO DRV_NAME ": "
+                       "Requires kernel with CONFIG_HOTPLUG, sorry!\n");
+#endif
+       }
+
+       return pci_module_init(&sis645_driver);
+}
+
+static void __exit i2c_sis645_exit(void)
+{
+       pci_unregister_driver(&sis645_driver);
+}
+
+MODULE_AUTHOR("Mark M. Hoffman <mhoffman@lightlink.com>");
+MODULE_DESCRIPTION("SiS645 SMBus driver");
+MODULE_LICENSE("GPL");
+
+/* Register initialization functions using helper macros */
+module_init(i2c_sis645_init);
+module_exit(i2c_sis645_exit);
--- linux-old/drivers/i2c/i2c-tsunami.c Thu Jan  1 00:00:00 1970
+++ linux/drivers/i2c/i2c-tsunami.c     Mon Dec 13 20:18:42 2004
@@ -0,0 +1,155 @@
+/*
+    i2c-tsunami.c - Part of lm_sensors, Linux kernel modules for hardware
+              monitoring
+    Copyright (c) 2001  Oleg Vdovikin <vdovikin@jscc.ru>
+    
+    Based on code written by Ralph Metzler <rjkm@thp.uni-koeln.de> and
+    Simon Vogl
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/* This interfaces to the I2C bus of the Tsunami/Typhoon 21272 chipsets 
+   to gain access to the on-board I2C devices. 
+
+   For more information refer to Compaq's 
+       "Tsunami/Typhoon 21272 Chipset Hardware Reference Manual"
+       Order Number: DS-0025-TE
+*/ 
+
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/i2c-algo-bit.h>
+#include <linux/init.h>
+#include <asm/io.h>
+#include <asm/hwrpb.h>
+#include <asm/core_tsunami.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+MODULE_LICENSE("GPL");
+
+/* Memory Presence Detect Register (MPD-RW) bits 
+   with except of reserved RAZ bits */
+
+#define MPD_DR 0x8     /* Data receive - RO */
+#define MPD_CKR        0x4     /* Clock receive - RO */
+#define MPD_DS 0x2     /* Data send - Must be a 1 to receive - WO */
+#define MPD_CKS        0x1     /* Clock send - WO */
+
+static inline void writempd(unsigned long value)
+{
+       TSUNAMI_cchip->mpd.csr = value;
+       mb();
+}
+
+static inline unsigned long readmpd(void)
+{
+       return TSUNAMI_cchip->mpd.csr;
+}
+
+static void bit_tsunami_setscl(void *data, int val)
+{
+       /* read currently setted bits to modify them */
+       unsigned long bits = readmpd() >> 2; /* assume output == input */
+
+       if (val)
+               bits |= MPD_CKS;
+       else
+               bits &= ~MPD_CKS;
+
+       writempd(bits);
+}
+
+static void bit_tsunami_setsda(void *data, int val)
+{
+       /* read currently setted bits to modify them */
+       unsigned long bits = readmpd() >> 2; /* assume output == input */
+
+       if (val)
+               bits |= MPD_DS;
+       else
+               bits &= ~MPD_DS;
+
+       writempd(bits);
+}
+
+/* The MPD pins are open drain, so the pins always remain outputs.
+   We rely on the i2c-algo-bit routines to set the pins high before
+   reading the input from other chips. */
+
+static int bit_tsunami_getscl(void *data)
+{
+       return (0 != (readmpd() & MPD_CKR));
+}
+
+static int bit_tsunami_getsda(void *data)
+{
+       return (0 != (readmpd() & MPD_DR));
+}
+
+static struct i2c_algo_bit_data tsunami_i2c_bit_data = {
+       .setsda         = bit_tsunami_setsda,
+       .setscl         = bit_tsunami_setscl,
+       .getsda         = bit_tsunami_getsda,
+       .getscl         = bit_tsunami_getscl,
+       .udelay         = 10,
+       .mdelay         = 10,
+       .timeout        = HZ/2
+};
+
+static struct i2c_adapter tsunami_i2c_adapter = {
+       .owner          = THIS_MODULE,
+       .name           = "I2C Tsunami/Typhoon adapter",
+       .id             = I2C_HW_B_TSUNA,
+       .algo_data      = &tsunami_i2c_bit_data,
+};
+
+
+#if 0
+static struct pci_driver tsunami_driver = {
+       .name           = "tsunami smbus",
+       .id_table       = tsunami_ids,
+       .probe          = tsunami_probe,
+       .remove         = __devexit_p(tsunami_remove),
+};
+#endif
+
+static int __init i2c_tsunami_init(void)
+{
+       printk("i2c-tsunami.o version %s (%s)\n", LM_VERSION, LM_DATE);
+
+       if (hwrpb->sys_type != ST_DEC_TSUNAMI) {
+               printk("i2c-tsunami.o: not Tsunami based system (%ld), module not inserted.\n", hwrpb->sys_type);
+               return -ENXIO;
+       } else {
+               printk("i2c-tsunami.o: using Cchip MPD at 0x%lx.\n", (long) &TSUNAMI_cchip->mpd);
+       }
+       return i2c_bit_add_bus(&tsunami_i2c_adapter);
+}
+
+
+static void __exit i2c_tsunami_exit(void)
+{
+       i2c_bit_del_bus(&tsunami_i2c_adapter);
+}
+
+
+
+MODULE_AUTHOR("Oleg I. Vdovikin <vdovikin@jscc.ru>");
+MODULE_DESCRIPTION("Tsunami I2C/SMBus driver");
+
+module_init(i2c_tsunami_init);
+module_exit(i2c_tsunami_exit);
--- linux-old/drivers/i2c/i2c-via.c     Thu Jan  1 00:00:00 1970
+++ linux/drivers/i2c/i2c-via.c Mon Dec 13 20:18:42 2004
@@ -0,0 +1,207 @@
+/*
+    i2c-via.c - Part of lm_sensors,  Linux kernel modules
+                for hardware monitoring
+
+    i2c Support for Via Technologies 82C586B South Bridge
+
+    Copyright (c) 1998, 1999 Kyösti Mälkki <kmalkki@cc.hut.fi>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include <linux/kernel.h>
+#include <linux/ioport.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/types.h>
+#include <linux/i2c.h>
+#include <linux/i2c-algo-bit.h>
+#include <linux/init.h>
+#include <asm/io.h>
+#include <asm/param.h> /* for HZ */
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+/* Power management registers */
+
+#define PM_CFG_REVID    0x08   /* silicon revision code */
+#define PM_CFG_IOBASE0  0x20
+#define PM_CFG_IOBASE1  0x48
+
+#define I2C_DIR                (pm_io_base+0x40)
+#define I2C_OUT                (pm_io_base+0x42)
+#define I2C_IN         (pm_io_base+0x44)
+#define I2C_SCL                0x02    /* clock bit in DIR/OUT/IN register */
+#define I2C_SDA                0x04
+
+/* io-region reservation */
+#define IOSPACE                0x06
+#define IOTEXT         "via-i2c"
+
+static u16 pm_io_base = 0;
+
+/*
+   It does not appear from the datasheet that the GPIO pins are
+   open drain. So a we set a low value by setting the direction to
+   output and a high value by setting the direction to input and
+   relying on the required I2C pullup. The data value is initialized
+   to 0 in via_init() and never changed.
+*/
+
+static void bit_via_setscl(void *data, int state)
+{
+       outb(state ? inb(I2C_DIR) & ~I2C_SCL : inb(I2C_DIR) | I2C_SCL,
+            I2C_DIR);
+}
+
+static void bit_via_setsda(void *data, int state)
+{
+       outb(state ? inb(I2C_DIR) & ~I2C_SDA : inb(I2C_DIR) | I2C_SDA,
+            I2C_DIR);
+}
+
+static int bit_via_getscl(void *data)
+{
+       return (0 != (inb(I2C_IN) & I2C_SCL));
+}
+
+static int bit_via_getsda(void *data)
+{
+       return (0 != (inb(I2C_IN) & I2C_SDA));
+}
+
+
+static struct i2c_algo_bit_data bit_data = {
+       .setsda         = bit_via_setsda,
+       .setscl         = bit_via_setscl,
+       .getsda         = bit_via_getsda,
+       .getscl         = bit_via_getscl,
+       .udelay         = 5,
+       .mdelay         = 5,
+       .timeout        = HZ
+};
+
+static struct i2c_adapter vt586b_adapter = {
+       .owner          = THIS_MODULE,
+       .name           = "VIA i2c",
+       .id             = I2C_HW_B_VIA,
+       .algo_data      = &bit_data,
+};
+
+
+static struct pci_device_id vt586b_ids[] __devinitdata = {
+       { PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C586_3, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
+       { 0, }
+};
+
+static int __devinit vt586b_probe(struct pci_dev *dev, const struct pci_device_id *id)
+{
+       u16 base;
+       u8 rev;
+       int res;
+
+       if (pm_io_base) {
+               printk(KERN_ERR "i2c-via.o: Will only support one host\n");
+               return -EBUSY;
+       }
+
+       pci_read_config_byte(dev, PM_CFG_REVID, &rev);
+
+       switch (rev) {
+       case 0x00:
+               base = PM_CFG_IOBASE0;
+               break;
+       case 0x01:
+       case 0x10:
+               base = PM_CFG_IOBASE1;
+               break;
+
+       default:
+               base = PM_CFG_IOBASE1;
+               /* later revision */
+       }
+
+       pci_read_config_word(dev, base, &pm_io_base);
+       pm_io_base &= (0xff << 8);
+
+       if (! request_region(I2C_DIR, IOSPACE, IOTEXT)) {
+           printk("i2c-via.o: IO 0x%x-0x%x already in use\n",
+                  I2C_DIR, I2C_DIR + IOSPACE);
+           return -EBUSY;
+       }
+       outb(inb(I2C_DIR) & ~(I2C_SDA | I2C_SCL), I2C_DIR);
+       outb(inb(I2C_OUT) & ~(I2C_SDA | I2C_SCL), I2C_OUT);
+       
+       res = i2c_bit_add_bus(&vt586b_adapter);
+       if ( res < 0 ) {
+               release_region(I2C_DIR, IOSPACE);
+               pm_io_base = 0;
+               return res;
+       }
+       return 0;
+}
+
+static void __devexit vt586b_remove(struct pci_dev *dev)
+{
+       i2c_bit_del_bus(&vt586b_adapter);
+       release_region(I2C_DIR, IOSPACE);
+       pm_io_base = 0;
+}
+
+
+/* Don't register driver to avoid driver conflicts */
+/*
+static struct pci_driver vt586b_driver = {
+       .name           = "vt586b smbus",
+       .id_table       = vt586b_ids,
+       .probe          = vt586b_probe,
+       .remove         = __devexit_p(vt586b_remove),
+};
+*/
+
+static int __init i2c_vt586b_init(void)
+{
+       struct pci_dev *dev;
+       const struct pci_device_id *id;
+
+       printk("i2c-via.o version %s (%s)\n", LM_VERSION, LM_DATE);
+/*
+       return pci_module_init(&vt586b_driver);
+*/
+       pci_for_each_dev(dev) {
+               id = pci_match_device(vt586b_ids, dev);
+               if(id)
+                       if(vt586b_probe(dev, id) >= 0)
+                               return 0;
+       }
+       return -ENODEV;
+}
+
+
+static void __exit i2c_vt586b_exit(void)
+{
+/*
+       pci_unregister_driver(&vt586b_driver);
+*/
+       vt586b_remove(NULL);
+}
+
+
+MODULE_AUTHOR("Kyösti Mälkki <kmalkki@cc.hut.fi>");
+MODULE_DESCRIPTION("i2c for Via vt82c586b southbridge");
+MODULE_LICENSE("GPL");
+
+module_init(i2c_vt586b_init);
+module_exit(i2c_vt586b_exit);
--- linux-old/drivers/i2c/i2c-viapro.c  Thu Jan  1 00:00:00 1970
+++ linux/drivers/i2c/i2c-viapro.c      Mon Dec 13 20:18:43 2004
@@ -0,0 +1,514 @@
+/*
+    i2c-viapro.c - Part of lm_sensors, Linux kernel modules for hardware
+              monitoring
+    Copyright (c) 1998 - 2002  Frodo Looijaard <frodol@dds.nl>, 
+    Philip Edelbrock <phil@netroedge.com>, Kyösti Mälkki <kmalkki@cc.hut.fi>,
+    Mark D. Studebaker <mdsxyz123@yahoo.com>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+   Supports Via devices:
+       82C596A/B (0x3050)
+       82C596B (0x3051)
+       82C686A/B
+       8231
+       8233
+       8233A (0x3147 and 0x3177)
+       8235
+       8237
+   Note: we assume there can only be one device, with one SMBus interface.
+*/
+
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/kernel.h>
+#include <linux/stddef.h>
+#include <linux/sched.h>
+#include <linux/ioport.h>
+#include <linux/i2c.h>
+#include <linux/init.h>
+#include <asm/io.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+#include <linux/sensors_compat.h>
+
+#define SMBBA1          0x90
+#define SMBBA2          0x80
+#define SMBBA3          0xD0
+
+/* SMBus address offsets */
+static unsigned short vt596_smba;
+#define SMBHSTSTS      (vt596_smba + 0)
+#define SMBHSLVSTS     (vt596_smba + 1)
+#define SMBHSTCNT      (vt596_smba + 2)
+#define SMBHSTCMD      (vt596_smba + 3)
+#define SMBHSTADD      (vt596_smba + 4)
+#define SMBHSTDAT0     (vt596_smba + 5)
+#define SMBHSTDAT1     (vt596_smba + 6)
+#define SMBBLKDAT      (vt596_smba + 7)
+#define SMBSLVCNT      (vt596_smba + 8)
+#define SMBSHDWCMD     (vt596_smba + 9)
+#define SMBSLVEVT      (vt596_smba + 0xA)
+#define SMBSLVDAT      (vt596_smba + 0xC)
+
+/* PCI Address Constants */
+
+/* SMBus data in configuration space can be found in two places,
+   We try to select the better one*/
+
+static unsigned short smb_cf_hstcfg = 0xD2;
+
+#define SMBHSTCFG   (smb_cf_hstcfg)
+#define SMBSLVC     (smb_cf_hstcfg + 1)
+#define SMBSHDW1    (smb_cf_hstcfg + 2)
+#define SMBSHDW2    (smb_cf_hstcfg + 3)
+#define SMBREV      (smb_cf_hstcfg + 4)
+
+/* Other settings */
+#define MAX_TIMEOUT    500
+#define ENABLE_INT9    0
+
+/* VT82C596 constants */
+#define VT596_QUICK      0x00
+#define VT596_BYTE       0x04
+#define VT596_BYTE_DATA  0x08
+#define VT596_WORD_DATA  0x0C
+#define VT596_BLOCK_DATA 0x14
+
+
+/* If force is set to anything different from 0, we forcibly enable the
+   VT596. DANGEROUS! */
+static int force;
+MODULE_PARM(force, "i");
+MODULE_PARM_DESC(force, "Forcibly enable the SMBus. DANGEROUS!");
+
+/* If force_addr is set to anything different from 0, we forcibly enable
+   the VT596 at the given address. VERY DANGEROUS! */
+static int force_addr;
+MODULE_PARM(force_addr, "i");
+MODULE_PARM_DESC(force_addr,
+                "Forcibly enable the SMBus at the given address. "
+                "EXTREMELY DANGEROUS!");
+
+
+static struct i2c_adapter vt596_adapter;
+
+/* Another internally used function */
+static int vt596_transaction(void)
+{
+       int temp;
+       int result = 0;
+       int timeout = 0;
+
+       dev_dbg(&vt596_adapter, "Transaction (pre): CNT=%02x, CMD=%02x, "
+               "ADD=%02x, DAT0=%02x, DAT1=%02x\n", inb_p(SMBHSTCNT), 
+               inb_p(SMBHSTCMD), inb_p(SMBHSTADD), inb_p(SMBHSTDAT0), 
+               inb_p(SMBHSTDAT1));
+
+       /* Make sure the SMBus host is ready to start transmitting */
+       if ((temp = inb_p(SMBHSTSTS)) != 0x00) {
+               dev_dbg(&vt596_adapter, "SMBus busy (0x%02x). "
+                               "Resetting...\n", temp);
+               
+               outb_p(temp, SMBHSTSTS);
+               if ((temp = inb_p(SMBHSTSTS)) != 0x00) {
+                       dev_dbg(&vt596_adapter, "Failed! (0x%02x)\n", temp);
+                       
+                       return -1;
+               } else {
+                       dev_dbg(&vt596_adapter, "Successfull!\n");
+               }
+       }
+
+       /* start the transaction by setting bit 6 */
+       outb_p(inb(SMBHSTCNT) | 0x040, SMBHSTCNT);
+
+       /* We will always wait for a fraction of a second! 
+          I don't know if VIA needs this, Intel did  */
+       do {
+               i2c_delay(1);
+               temp = inb_p(SMBHSTSTS);
+       } while ((temp & 0x01) && (timeout++ < MAX_TIMEOUT));
+
+       /* If the SMBus is still busy, we give up */
+       if (timeout >= MAX_TIMEOUT) {
+               result = -1;
+               dev_dbg(&vt596_adapter, "SMBus Timeout!\n");
+       }
+
+       if (temp & 0x10) {
+               result = -1;
+               dev_dbg(&vt596_adapter, "Error: Failed bus transaction\n");
+       }
+
+       if (temp & 0x08) {
+               result = -1;
+               dev_info(&vt596_adapter, "Bus collision! SMBus may be "
+                       "locked until next hard\nreset. (sorry!)\n");
+               /* Clock stops and slave is stuck in mid-transmission */
+       }
+
+       if (temp & 0x04) {
+               result = -1;
+               dev_dbg(&vt596_adapter, "Error: no response!\n");
+       }
+
+       if (inb_p(SMBHSTSTS) != 0x00)
+               outb_p(inb(SMBHSTSTS), SMBHSTSTS);
+
+       if ((temp = inb_p(SMBHSTSTS)) != 0x00) {
+               dev_dbg(&vt596_adapter, "Failed reset at end of "
+                       "transaction (%02x)\n", temp);
+       }
+       dev_dbg(&vt596_adapter, "Transaction (post): CNT=%02x, CMD=%02x, "
+               "ADD=%02x, DAT0=%02x, DAT1=%02x\n", inb_p(SMBHSTCNT),
+               inb_p(SMBHSTCMD), inb_p(SMBHSTADD), inb_p(SMBHSTDAT0), 
+               inb_p(SMBHSTDAT1));
+       
+       return result;
+}
+
+/* Return -1 on error. */
+static s32 vt596_access(struct i2c_adapter *adap, u16 addr,
+               unsigned short flags,  char read_write, u8 command,
+               int size,  union i2c_smbus_data *data)
+{
+       int i, len;
+
+       switch (size) {
+       case I2C_SMBUS_QUICK:
+               outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
+                      SMBHSTADD);
+               size = VT596_QUICK;
+               break;
+       case I2C_SMBUS_BYTE:
+               outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
+                      SMBHSTADD);
+               if (read_write == I2C_SMBUS_WRITE)
+                       outb_p(command, SMBHSTCMD);
+               size = VT596_BYTE;
+               break;
+       case I2C_SMBUS_BYTE_DATA:
+               outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
+                      SMBHSTADD);
+               outb_p(command, SMBHSTCMD);
+               if (read_write == I2C_SMBUS_WRITE)
+                       outb_p(data->byte, SMBHSTDAT0);
+               size = VT596_BYTE_DATA;
+               break;
+       case I2C_SMBUS_WORD_DATA:
+               outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
+                      SMBHSTADD);
+               outb_p(command, SMBHSTCMD);
+               if (read_write == I2C_SMBUS_WRITE) {
+                       outb_p(data->word & 0xff, SMBHSTDAT0);
+                       outb_p((data->word & 0xff00) >> 8, SMBHSTDAT1);
+               }
+               size = VT596_WORD_DATA;
+               break;
+       case I2C_SMBUS_BLOCK_DATA:
+               outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
+                      SMBHSTADD);
+               outb_p(command, SMBHSTCMD);
+               if (read_write == I2C_SMBUS_WRITE) {
+                       len = data->block[0];
+                       if (len < 0)
+                               len = 0;
+                       if (len > 32)
+                               len = 32;
+                       outb_p(len, SMBHSTDAT0);
+                       i = inb_p(SMBHSTCNT);   /* Reset SMBBLKDAT */
+                       for (i = 1; i <= len; i++)
+                               outb_p(data->block[i], SMBBLKDAT);
+               }
+               size = VT596_BLOCK_DATA;
+               break;
+       default:
+               dev_warn(&vt596_adapter, "Unsupported transaction %d\n", size);
+               return -1;
+       }
+
+       outb_p((size & 0x1C) + (ENABLE_INT9 & 1), SMBHSTCNT);
+
+       if (vt596_transaction()) /* Error in transaction */
+               return -1;
+
+       if ((read_write == I2C_SMBUS_WRITE) || (size == VT596_QUICK))
+               return 0;
+
+       switch (size) {
+       case VT596_BYTE:
+               /* Where is the result put? I assume here it is in
+                * SMBHSTDAT0 but it might just as well be in the
+                * SMBHSTCMD. No clue in the docs 
+                */
+               data->byte = inb_p(SMBHSTDAT0);
+               break;
+       case VT596_BYTE_DATA:
+               data->byte = inb_p(SMBHSTDAT0);
+               break;
+       case VT596_WORD_DATA:
+               data->word = inb_p(SMBHSTDAT0) + (inb_p(SMBHSTDAT1) << 8);
+               break;
+       case VT596_BLOCK_DATA:
+               data->block[0] = inb_p(SMBHSTDAT0);
+               if (data->block[0] > 32)
+                       data->block[0] = 32;
+               i = inb_p(SMBHSTCNT);   /* Reset SMBBLKDAT */
+               for (i = 1; i <= data->block[0]; i++)
+                       data->block[i] = inb_p(SMBBLKDAT);
+               break;
+       }
+       return 0;
+}
+
+static u32 vt596_func(struct i2c_adapter *adapter)
+{
+       return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
+           I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
+           I2C_FUNC_SMBUS_BLOCK_DATA;
+}
+
+static struct i2c_algorithm smbus_algorithm = {
+       .name           = "Non-I2C SMBus adapter",
+       .id             = I2C_ALGO_SMBUS,
+       .smbus_xfer     = vt596_access,
+       .functionality  = vt596_func,
+};
+
+static struct i2c_adapter vt596_adapter = {
+       .owner          = THIS_MODULE,
+       .id             = I2C_ALGO_SMBUS | I2C_HW_SMBUS_VIA2,
+       .algo           = &smbus_algorithm,
+       .name   = "unset",
+};
+
+static int __devinit vt596_probe(struct pci_dev *pdev,
+                                const struct pci_device_id *id)
+{
+       unsigned char temp;
+       int error = -ENODEV;
+       
+       /* Determine the address of the SMBus areas */
+       if (force_addr) {
+               vt596_smba = force_addr & 0xfff0;
+               force = 0;
+               goto found;
+       }
+
+       if ((pci_read_config_word(pdev, id->driver_data, &vt596_smba)) ||
+           !(vt596_smba & 0x1)) {
+               /* try 2nd address and config reg. for 596 */
+               if (id->device == PCI_DEVICE_ID_VIA_82C596_3 &&
+                   !pci_read_config_word(pdev, SMBBA2, &vt596_smba) &&
+                   (vt596_smba & 0x1)) {
+                       smb_cf_hstcfg = 0x84;
+               } else {
+                       /* no matches at all */
+                       dev_err(pdev, "Cannot configure "
+                               "SMBus I/O Base address\n");
+                       return -ENODEV;
+               }
+       }
+
+       vt596_smba &= 0xfff0;
+       if (vt596_smba == 0) {
+               dev_err(pdev, "SMBus base address "
+                       "uninitialized - upgrade BIOS or use "
+                       "force_addr=0xaddr\n");
+               return -ENODEV;
+       }
+
+ found:
+       if (!request_region(vt596_smba, 8, "viapro-smbus")) {
+               dev_err(pdev, "SMBus region 0x%x already in use!\n",
+                       vt596_smba);
+               return -ENODEV;
+       }
+
+       pci_read_config_byte(pdev, SMBHSTCFG, &temp);
+       /* If force_addr is set, we program the new address here. Just to make
+          sure, we disable the VT596 first. */
+       if (force_addr) {
+               pci_write_config_byte(pdev, SMBHSTCFG, temp & 0xfe);
+               pci_write_config_word(pdev, id->driver_data, vt596_smba);
+               pci_write_config_byte(pdev, SMBHSTCFG, temp | 0x01);
+               dev_warn(pdev, "WARNING: SMBus interface set to new "
+                    "address 0x%04x!\n", vt596_smba);
+       } else if ((temp & 1) == 0) {
+               if (force) {
+                       /* NOTE: This assumes I/O space and other allocations 
+                        * WERE done by the Bios!  Don't complain if your 
+                        * hardware does weird things after enabling this. 
+                        * :') Check for Bios updates before resorting to 
+                        * this.
+                        */
+                       pci_write_config_byte(pdev, SMBHSTCFG, temp | 1);
+                       dev_info(pdev, "Enabling SMBus device\n");
+               } else {
+                       dev_err(pdev, "SMBUS: Error: Host SMBus "
+                               "controller not enabled! - upgrade BIOS or "
+                               "use force=1\n");
+                       goto release_region;
+               }
+       }
+
+       if ((temp & 0x0E) == 8)
+               dev_dbg(pdev, "using Interrupt 9 for SMBus.\n");
+       else if ((temp & 0x0E) == 0)
+               dev_dbg(pdev, "using Interrupt SMI# for SMBus.\n");
+       else
+               dev_dbg(pdev, "Illegal Interrupt configuration "
+                       "(or code out of date)!\n");
+
+       pci_read_config_byte(pdev, SMBREV, &temp);
+       dev_dbg(pdev, "SMBREV = 0x%X\n", temp);
+       dev_dbg(pdev, "VT596_smba = 0x%X\n", vt596_smba);
+
+       snprintf(vt596_adapter.name, 32,
+                       "SMBus Via Pro adapter at %04x", vt596_smba);
+       
+       return i2c_add_adapter(&vt596_adapter);
+
+ release_region:
+       release_region(vt596_smba, 8);
+       return error;
+}
+
+static void __devexit vt596_remove(struct pci_dev *pdev)
+{
+       i2c_del_adapter(&vt596_adapter);
+       release_region(vt596_smba, 8);
+}
+
+/* 8233A is undefined before kernel 2.4.19 */
+#ifndef PCI_DEVICE_ID_VIA_8233A
+#define PCI_DEVICE_ID_VIA_8233A        0x3147
+#endif
+/* 8235 is undefined before kernel 2.4.20 */
+#ifndef PCI_DEVICE_ID_VIA_8235
+#define PCI_DEVICE_ID_VIA_8235 0x3177
+#endif
+/* 8237 is undefined before kernel 2.4.21 */
+#ifndef PCI_DEVICE_ID_VIA_8237
+#define PCI_DEVICE_ID_VIA_8237 0x3227
+#endif
+static struct pci_device_id vt596_ids[] __devinitdata = {
+       {
+               .vendor         = PCI_VENDOR_ID_VIA,
+               .device         = PCI_DEVICE_ID_VIA_82C596_3,
+               .subvendor      = PCI_ANY_ID,
+               .subdevice      = PCI_ANY_ID,
+               .driver_data    = SMBBA1,
+       },
+       {
+               .vendor         = PCI_VENDOR_ID_VIA,
+               .device         = PCI_DEVICE_ID_VIA_82C596B_3,
+               .subvendor      = PCI_ANY_ID,
+               .subdevice      = PCI_ANY_ID,
+               .driver_data    = SMBBA1,
+       },
+       {
+               .vendor         = PCI_VENDOR_ID_VIA,
+               .device         = PCI_DEVICE_ID_VIA_82C686_4,
+               .subvendor      = PCI_ANY_ID,
+               .subdevice      = PCI_ANY_ID,
+               .driver_data    = SMBBA1,
+       },
+       {
+               .vendor         = PCI_VENDOR_ID_VIA,
+               .device         = PCI_DEVICE_ID_VIA_8233_0,
+               .subvendor      = PCI_ANY_ID,
+               .subdevice      = PCI_ANY_ID,
+               .driver_data    = SMBBA3
+       },
+       {
+               .vendor         = PCI_VENDOR_ID_VIA,
+               .device         = PCI_DEVICE_ID_VIA_8233A,
+               .subvendor      = PCI_ANY_ID,
+               .subdevice      = PCI_ANY_ID,
+               .driver_data    = SMBBA3,
+       },
+       {
+               .vendor         = PCI_VENDOR_ID_VIA,
+               .device         = PCI_DEVICE_ID_VIA_8235,
+               .subvendor      = PCI_ANY_ID,
+               .subdevice      = PCI_ANY_ID,
+               .driver_data    = SMBBA3
+       },
+       {
+               .vendor         = PCI_VENDOR_ID_VIA,
+               .device         = PCI_DEVICE_ID_VIA_8237,
+               .subvendor      = PCI_ANY_ID,
+               .subdevice      = PCI_ANY_ID,
+               .driver_data    = SMBBA3
+       },
+       {
+               .vendor         = PCI_VENDOR_ID_VIA,
+               .device         = PCI_DEVICE_ID_VIA_8231_4,
+               .subvendor      = PCI_ANY_ID,
+               .subdevice      = PCI_ANY_ID,
+               .driver_data    = SMBBA1,
+       },
+       { 0, }
+};
+
+/* Don't register driver to avoid driver conflicts */
+/*
+static struct pci_driver vt596_driver = {
+       .name           = "vt596 smbus",
+       .id_table       = vt596_ids,
+       .probe          = vt596_probe,
+       .remove         = __devexit_p(vt596_remove),
+};
+*/
+
+static int __init i2c_vt596_init(void)
+{
+       struct pci_dev *dev;
+       const struct pci_device_id *id;
+
+       printk("i2c-viapro.o version %s (%s)\n", LM_VERSION, LM_DATE);
+/*
+       return pci_module_init(&vt596_driver);
+*/
+       pci_for_each_dev(dev) {
+               id = pci_match_device(vt596_ids, dev);
+               if(id)
+                       if(vt596_probe(dev, id) >= 0)
+                               return 0;
+       }
+       return -ENODEV;
+}
+
+
+static void __exit i2c_vt596_exit(void)
+{
+/*
+       pci_unregister_driver(&vt596_driver);
+*/
+       vt596_remove(NULL);
+}
+
+MODULE_AUTHOR(
+    "Frodo Looijaard <frodol@dds.nl> and "
+    "Philip Edelbrock <phil@netroedge.com>");
+MODULE_DESCRIPTION("vt82c596 SMBus driver");
+MODULE_LICENSE("GPL");
+
+module_init(i2c_vt596_init);
+module_exit(i2c_vt596_exit);
--- linux-old/drivers/i2c/i2c-voodoo3.c Thu Jan  1 00:00:00 1970
+++ linux/drivers/i2c/i2c-voodoo3.c     Mon Dec 13 20:18:43 2004
@@ -0,0 +1,281 @@
+/*
+    voodoo3.c - Part of lm_sensors, Linux kernel modules for hardware
+              monitoring
+    Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl>,
+    Philip Edelbrock <phil@netroedge.com>,
+    Ralph Metzler <rjkm@thp.uni-koeln.de>, and
+    Mark D. Studebaker <mdsxyz123@yahoo.com>
+    
+    Based on code written by Ralph Metzler <rjkm@thp.uni-koeln.de> and
+    Simon Vogl
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/* This interfaces to the I2C bus of the Voodoo3 to gain access to
+    the BT869 and possibly other I2C devices. */
+
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/i2c.h>
+#include <linux/i2c-algo-bit.h>
+#include <linux/init.h>
+#include <asm/io.h>
+#include <asm/param.h> /* for HZ */
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+MODULE_LICENSE("GPL");
+
+/* the only registers we use */
+#define REG    0x78
+#define REG2   0x70
+
+/* bit locations in the register */
+#define DDC_ENAB       0x00040000
+#define DDC_SCL_OUT    0x00080000
+#define DDC_SDA_OUT    0x00100000
+#define DDC_SCL_IN     0x00200000
+#define DDC_SDA_IN     0x00400000
+#define I2C_ENAB       0x00800000
+#define I2C_SCL_OUT    0x01000000
+#define I2C_SDA_OUT    0x02000000
+#define I2C_SCL_IN     0x04000000
+#define I2C_SDA_IN     0x08000000
+
+/* initialization states */
+#define INIT2  0x2
+#define INIT3  0x4
+
+/* delays */
+#define CYCLE_DELAY    10
+#define TIMEOUT                (HZ / 2)
+
+
+static void config_v3(struct pci_dev *dev);
+
+static unsigned long ioaddr;
+
+/* The voo GPIO registers don't have individual masks for each bit
+   so we always have to read before writing. */
+
+static void bit_vooi2c_setscl(void *data, int val)
+{
+       unsigned int r;
+       r = readl(ioaddr + REG);
+       if(val)
+               r |= I2C_SCL_OUT;
+       else
+               r &= ~I2C_SCL_OUT;
+       writel(r, ioaddr + REG);
+       readl(ioaddr + REG);    /* flush posted write */
+}
+
+static void bit_vooi2c_setsda(void *data, int val)
+{
+       unsigned int r;
+       r = readl(ioaddr + REG);
+       if(val)
+               r |= I2C_SDA_OUT;
+       else
+               r &= ~I2C_SDA_OUT;
+       writel(r, ioaddr + REG);
+       readl(ioaddr + REG);    /* flush posted write */
+}
+
+/* The GPIO pins are open drain, so the pins always remain outputs.
+   We rely on the i2c-algo-bit routines to set the pins high before
+   reading the input from other chips. */
+
+static int bit_vooi2c_getscl(void *data)
+{
+       return (0 != (readl(ioaddr + REG) & I2C_SCL_IN));
+}
+
+static int bit_vooi2c_getsda(void *data)
+{
+       return (0 != (readl(ioaddr + REG) & I2C_SDA_IN));
+}
+
+static void bit_vooddc_setscl(void *data, int val)
+{
+       unsigned int r;
+       r = readl(ioaddr + REG);
+       if(val)
+               r |= DDC_SCL_OUT;
+       else
+               r &= ~DDC_SCL_OUT;
+       writel(r, ioaddr + REG);
+       readl(ioaddr + REG);    /* flush posted write */
+}
+
+static void bit_vooddc_setsda(void *data, int val)
+{
+       unsigned int r;
+       r = readl(ioaddr + REG);
+       if(val)
+               r |= DDC_SDA_OUT;
+       else
+               r &= ~DDC_SDA_OUT;
+       writel(r, ioaddr + REG);
+       readl(ioaddr + REG);    /* flush posted write */
+}
+
+static int bit_vooddc_getscl(void *data)
+{
+       return (0 != (readl(ioaddr + REG) & DDC_SCL_IN));
+}
+
+static int bit_vooddc_getsda(void *data)
+{
+       return (0 != (readl(ioaddr + REG) & DDC_SDA_IN));
+}
+
+
+/* Configures the chip */
+
+void config_v3(struct pci_dev *dev)
+{
+       unsigned int cadr;
+
+       /* map Voodoo3 memory */
+       cadr = dev->resource[0].start;
+       cadr &= PCI_BASE_ADDRESS_MEM_MASK;
+       ioaddr = (unsigned long)ioremap_nocache(cadr, 0x1000);
+       if(ioaddr) {
+               writel(0x8160, ioaddr + REG2);
+               writel(0xcffc0020, ioaddr + REG);
+               printk("i2c-voodoo3: Using Banshee/Voodoo3 at 0x%lx\n", ioaddr);
+       }
+}
+
+static struct i2c_algo_bit_data voo_i2c_bit_data = {
+       .setsda         = bit_vooi2c_setsda,
+       .setscl         = bit_vooi2c_setscl,
+       .getsda         = bit_vooi2c_getsda,
+       .getscl         = bit_vooi2c_getscl,
+       .udelay         = CYCLE_DELAY,
+       .mdelay         = CYCLE_DELAY,
+       .timeout        = TIMEOUT
+};
+
+static struct i2c_adapter voodoo3_i2c_adapter = {
+       .owner          = THIS_MODULE,
+       .name           = "I2C Voodoo3/Banshee adapter",
+       .id             = I2C_HW_B_VOO,
+       .algo_data              = &voo_i2c_bit_data,
+};
+
+static struct i2c_algo_bit_data voo_ddc_bit_data = {
+       .setsda         = bit_vooddc_setsda,
+       .setscl         = bit_vooddc_setscl,
+       .getsda         = bit_vooddc_getsda,
+       .getscl         = bit_vooddc_getscl,
+       .udelay         = CYCLE_DELAY,
+       .mdelay         = CYCLE_DELAY,
+       .timeout        = TIMEOUT
+};
+
+static struct i2c_adapter voodoo3_ddc_adapter = {
+       .owner          = THIS_MODULE,
+       .name           = "DDC Voodoo3/Banshee adapter",
+       .id             = I2C_HW_B_VOO,
+       .algo_data      = &voo_ddc_bit_data,
+};
+
+
+static struct pci_device_id voodoo3_ids[] __devinitdata = {
+       {
+               .vendor =       PCI_VENDOR_ID_3DFX,
+               .device =       PCI_DEVICE_ID_3DFX_VOODOO3,
+               .subvendor =    PCI_ANY_ID,
+               .subdevice =    PCI_ANY_ID,
+       },
+       {
+               .vendor =       PCI_VENDOR_ID_3DFX,
+               .device =       PCI_DEVICE_ID_3DFX_BANSHEE,
+               .subvendor =    PCI_ANY_ID,
+               .subdevice =    PCI_ANY_ID,
+       },
+       { 0, }
+};
+
+static int __devinit voodoo3_probe(struct pci_dev *dev, const struct pci_device_id *id)
+{
+       int retval;
+
+       printk("voodoo3: in probe\n");
+       config_v3(dev);
+       retval = i2c_bit_add_bus(&voodoo3_i2c_adapter);
+       if(retval)
+               return retval;
+       retval = i2c_bit_add_bus(&voodoo3_ddc_adapter);
+       if(retval)
+               i2c_bit_del_bus(&voodoo3_i2c_adapter);
+       return retval;
+}
+
+static void __devexit voodoo3_remove(struct pci_dev *dev)
+{
+       i2c_bit_del_bus(&voodoo3_i2c_adapter);
+       i2c_bit_del_bus(&voodoo3_ddc_adapter);
+}
+
+
+/* Don't register driver to avoid driver conflicts */
+/*
+static struct pci_driver voodoo3_driver = {
+       .name           = "voodoo3 smbus",
+       .id_table       = voodoo3_ids,
+       .probe          = voodoo3_probe,
+       .remove         = __devexit_p(voodoo3_remove),
+};
+*/
+
+static int __init i2c_voodoo3_init(void)
+{
+       struct pci_dev *dev;
+       const struct pci_device_id *id;
+
+       printk("i2c-voodoo3.o version %s (%s)\n", LM_VERSION, LM_DATE);
+/*
+       return pci_module_init(&voodoo3_driver);
+*/
+       pci_for_each_dev(dev) {
+               id = pci_match_device(voodoo3_ids, dev);
+               if(id)
+                       if(voodoo3_probe(dev, id) >= 0)
+                               return 0;
+       }
+       return -ENODEV;
+}
+
+
+static void __exit i2c_voodoo3_exit(void)
+{
+/*
+       pci_unregister_driver(&voodoo3_driver);
+*/
+       voodoo3_remove(NULL);
+       iounmap((void *)ioaddr);
+}
+
+
+MODULE_AUTHOR
+    ("Frodo Looijaard <frodol@dds.nl>, Philip Edelbrock <phil@netroedge.com>, Ralph Metzler <rjkm@thp.uni-koeln.de>, and Mark D. Studebaker <mdsxyz123@yahoo.com>");
+MODULE_DESCRIPTION("Voodoo3 I2C/SMBus driver");
+
+module_init(i2c_voodoo3_init);
+module_exit(i2c_voodoo3_exit);
--- linux-old/drivers/sensors/adm1021.c Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/adm1021.c     Mon Dec 13 20:18:43 2004
@@ -0,0 +1,594 @@
+/*
+    adm1021.c - Part of lm_sensors, Linux kernel modules for hardware
+             monitoring
+    Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl> and
+    Philip Edelbrock <phil@netroedge.com>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = { SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { 0x18, 0x1a, 0x29, 0x2b,
+       0x4c, 0x4e, SENSORS_I2C_END
+};
+static unsigned int normal_isa[] = { SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+/* Insmod parameters */
+SENSORS_INSMOD_8(adm1021, adm1023, max1617, max1617a, thmc10, lm84, gl523sm, mc1066);
+
+/* adm1021 constants specified below */
+
+/* The adm1021 registers */
+/* Read-only */
+#define ADM1021_REG_TEMP 0x00
+#define ADM1021_REG_REMOTE_TEMP 0x01
+#define ADM1021_REG_STATUS 0x02
+#define ADM1021_REG_MAN_ID 0x0FE       /* 0x41 = Analog Devices, 0x49 = TI,
+                                       0x4D = Maxim, 0x23 = Genesys , 0x54 = Onsemi*/
+#define ADM1021_REG_DEV_ID 0x0FF       /* ADM1021 = 0x0X, ADM1021A/ADM1023 = 0x3X */
+#define ADM1021_REG_DIE_CODE 0x0FF     /* MAX1617A */
+/* These use different addresses for reading/writing */
+#define ADM1021_REG_CONFIG_R 0x03
+#define ADM1021_REG_CONFIG_W 0x09
+#define ADM1021_REG_CONV_RATE_R 0x04
+#define ADM1021_REG_CONV_RATE_W 0x0A
+/* These are for the ADM1023's additional precision on the remote temp sensor */
+#define ADM1021_REG_REM_TEMP_PREC 0x010
+#define ADM1021_REG_REM_OFFSET 0x011
+#define ADM1021_REG_REM_OFFSET_PREC 0x012
+#define ADM1021_REG_REM_TOS_PREC 0x013
+#define ADM1021_REG_REM_THYST_PREC 0x014
+/* limits */
+#define ADM1021_REG_TOS_R 0x05
+#define ADM1021_REG_TOS_W 0x0B
+#define ADM1021_REG_REMOTE_TOS_R 0x07
+#define ADM1021_REG_REMOTE_TOS_W 0x0D
+#define ADM1021_REG_THYST_R 0x06
+#define ADM1021_REG_THYST_W 0x0C
+#define ADM1021_REG_REMOTE_THYST_R 0x08
+#define ADM1021_REG_REMOTE_THYST_W 0x0E
+/* write-only */
+#define ADM1021_REG_ONESHOT 0x0F
+
+#define ADM1021_ALARM_TEMP (ADM1021_ALARM_TEMP_HIGH | ADM1021_ALARM_TEMP_LOW)
+#define ADM1021_ALARM_RTEMP (ADM1021_ALARM_RTEMP_HIGH | ADM1021_ALARM_RTEMP_LOW\
+                             | ADM1021_ALARM_RTEMP_NA)
+#define ADM1021_ALARM_ALL  (ADM1021_ALARM_TEMP | ADM1021_ALARM_RTEMP)
+
+/* Conversions. Rounding and limit checking is only done on the TO_REG
+   variants. Note that you should be a bit careful with which arguments
+   these macros are called: arguments may be evaluated more than once.
+   Fixing this is just not worth it. */
+/* Conversions  note: 1021 uses normal integer signed-byte format*/
+#define TEMP_FROM_REG(val) (val > 127 ? val-256 : val)
+#define TEMP_TO_REG(val)   (SENSORS_LIMIT((val < 0 ? val+256 : val),0,255))
+
+/* Each client has this additional data */
+struct adm1021_data {
+       struct i2c_client client;
+       int sysctl_id;
+       enum chips type;
+
+       struct semaphore update_lock;
+       char valid;             /* !=0 if following fields are valid */
+       unsigned long last_updated;     /* In jiffies */
+
+       u8 temp, temp_os, temp_hyst;    /* Register values */
+       u8 remote_temp, remote_temp_os, remote_temp_hyst, alarms, die_code;
+       u8 fail;
+        /* Special values for ADM1023 only */
+       u8 remote_temp_prec, remote_temp_os_prec, remote_temp_hyst_prec, 
+          remote_temp_offset, remote_temp_offset_prec;
+};
+
+static int adm1021_attach_adapter(struct i2c_adapter *adapter);
+static int adm1021_detect(struct i2c_adapter *adapter, int address,
+                         unsigned short flags, int kind);
+static void adm1021_init_client(struct i2c_client *client);
+static int adm1021_detach_client(struct i2c_client *client);
+static int adm1021_read_value(struct i2c_client *client, u8 reg);
+static int adm1021_rd_good(u8 *val, struct i2c_client *client, u8 reg, u8 mask);
+static int adm1021_write_value(struct i2c_client *client, u8 reg,
+                              u16 value);
+static void adm1021_temp(struct i2c_client *client, int operation,
+                        int ctl_name, int *nrels_mag, long *results);
+static void adm1021_remote_temp(struct i2c_client *client, int operation,
+                               int ctl_name, int *nrels_mag,
+                               long *results);
+static void adm1021_alarms(struct i2c_client *client, int operation,
+                          int ctl_name, int *nrels_mag, long *results);
+static void adm1021_die_code(struct i2c_client *client, int operation,
+                            int ctl_name, int *nrels_mag, long *results);
+static void adm1021_update_client(struct i2c_client *client);
+
+/* (amalysh) read only mode, otherwise any limit's writing confuse BIOS */
+static int read_only = 0;
+
+
+/* This is the driver that will be inserted */
+static struct i2c_driver adm1021_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "ADM1021, MAX1617 sensor driver",
+       .id             = I2C_DRIVERID_ADM1021,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = adm1021_attach_adapter,
+       .detach_client  = adm1021_detach_client,
+};
+
+/* -- SENSORS SYSCTL START -- */
+
+#define ADM1021_SYSCTL_TEMP 1200
+#define ADM1021_SYSCTL_REMOTE_TEMP 1201
+#define ADM1021_SYSCTL_DIE_CODE 1202
+#define ADM1021_SYSCTL_ALARMS 1203
+
+#define ADM1021_ALARM_TEMP_HIGH 0x40
+#define ADM1021_ALARM_TEMP_LOW 0x20
+#define ADM1021_ALARM_RTEMP_HIGH 0x10
+#define ADM1021_ALARM_RTEMP_LOW 0x08
+#define ADM1021_ALARM_RTEMP_NA 0x04
+
+/* -- SENSORS SYSCTL END -- */
+
+/* These files are created for each detected adm1021. This is just a template;
+   though at first sight, you might think we could use a statically
+   allocated list, we need some way to get back to the parent - which
+   is done through one of the 'extra' fields which are initialized
+   when a new copy is allocated. */
+static ctl_table adm1021_dir_table_template[] = {
+       {ADM1021_SYSCTL_TEMP, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm1021_temp},
+       {ADM1021_SYSCTL_REMOTE_TEMP, "temp2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm1021_remote_temp},
+       {ADM1021_SYSCTL_DIE_CODE, "die_code", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm1021_die_code},
+       {ADM1021_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm1021_alarms},
+       {0}
+};
+
+static ctl_table adm1021_max_dir_table_template[] = {
+       {ADM1021_SYSCTL_TEMP, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm1021_temp},
+       {ADM1021_SYSCTL_REMOTE_TEMP, "temp2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm1021_remote_temp},
+       {ADM1021_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm1021_alarms},
+       {0}
+};
+
+static int adm1021_id = 0;
+
+static int adm1021_attach_adapter(struct i2c_adapter *adapter)
+{
+       return i2c_detect(adapter, &addr_data, adm1021_detect);
+}
+
+static int adm1021_detect(struct i2c_adapter *adapter, int address,
+                         unsigned short flags, int kind)
+{
+       int i;
+       struct i2c_client *new_client;
+       struct adm1021_data *data;
+       int err = 0;
+       const char *type_name = "";
+       const char *client_name = "";
+
+       /* Make sure we aren't probing the ISA bus!! This is just a safety check
+          at this moment; i2c_detect really won't call us. */
+#ifdef DEBUG
+       if (i2c_is_isa_adapter(adapter)) {
+               printk
+                   ("adm1021.o: adm1021_detect called for an ISA bus adapter?!?\n");
+               return 0;
+       }
+#endif
+
+       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
+               goto error0;
+
+       /* OK. For now, we presume we have a valid client. We now create the
+          client structure, even though we cannot fill it completely yet.
+          But it allows us to access adm1021_{read,write}_value. */
+
+       if (!(data = kmalloc(sizeof(struct adm1021_data), GFP_KERNEL))) {
+               err = -ENOMEM;
+               goto error0;
+       }
+
+       new_client = &data->client;
+       new_client->addr = address;
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &adm1021_driver;
+       new_client->flags = 0;
+
+       /* Now, we do the remaining detection. */
+
+       if (kind < 0) {
+               if ((adm1021_read_value(new_client, ADM1021_REG_STATUS) & 0x03) != 0x00
+                || (adm1021_read_value(new_client, ADM1021_REG_CONFIG_R) & 0x3F) != 0x00
+                || (adm1021_read_value(new_client, ADM1021_REG_CONV_RATE_R) & 0xF8) != 0x00) {
+                       err = -ENODEV;
+                       goto error1;
+               }
+       }
+
+       /* Determine the chip type. */
+
+       if (kind <= 0) {
+               i = adm1021_read_value(new_client, ADM1021_REG_MAN_ID);
+               if (i == 0x41)
+                 if ((adm1021_read_value (new_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) &&
+                        (adm1021_read_value
+                         (new_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 (adm1021_read_value(new_client, ADM1021_REG_CONV_RATE_R) == 0x00
+                     && (kind == 0 /* skip extra detection */
+                      || ((adm1021_read_value(new_client, ADM1021_REG_CONFIG_R) & 0x7F) == 0x00
+                       && (adm1021_read_value(new_client, ADM1021_REG_STATUS) & 0xAB) == 0x00)))
+                       kind = lm84;
+               else
+                       kind = max1617;
+       }
+
+       if (kind == max1617) {
+               type_name = "max1617";
+               client_name = "MAX1617 chip";
+       } else if (kind == max1617a) {
+               type_name = "max1617a";
+               client_name = "MAX1617A chip";
+       } else if (kind == adm1021) {
+               type_name = "adm1021";
+               client_name = "ADM1021 chip";
+       } else if (kind == adm1023) {
+               type_name = "adm1023";
+               client_name = "ADM1023 chip";
+       } else if (kind == thmc10) {
+               type_name = "thmc10";
+               client_name = "THMC10 chip";
+       } else if (kind == lm84) {
+               type_name = "lm84";
+               client_name = "LM84 chip";
+       } else if (kind == gl523sm) {
+               type_name = "gl523sm";
+               client_name = "GL523SM chip";
+       } else if (kind == mc1066) {
+               type_name = "mc1066";
+               client_name = "MC1066 chip";
+       }
+
+       /* Fill in the remaining client fields and put it into the global list */
+       strcpy(new_client->name, client_name);
+       data->type = kind;
+
+       new_client->id = adm1021_id++;
+       data->valid = 0;
+       init_MUTEX(&data->update_lock);
+
+       /* Tell the I2C layer a new client has arrived */
+       if ((err = i2c_attach_client(new_client)))
+               goto error3;
+
+       /* Register a new directory entry with module sensors */
+       if ((i = i2c_register_entry(new_client, type_name,
+                                       data->type == adm1021 ? adm1021_dir_table_template :
+                                       adm1021_max_dir_table_template)) < 0) {
+               err = i;
+               goto error4;
+       }
+       data->sysctl_id = i;
+
+       /* Initialize the ADM1021 chip */
+       if (kind != lm84)
+               adm1021_init_client(new_client);
+       return 0;
+
+      error4:
+       i2c_detach_client(new_client);
+      error3:
+      error1:
+       kfree(data);
+      error0:
+       return err;
+}
+
+static void adm1021_init_client(struct i2c_client *client)
+{
+       /* Enable ADC and disable suspend mode */
+       adm1021_write_value(client, ADM1021_REG_CONFIG_W,
+               adm1021_read_value(client, ADM1021_REG_CONFIG_R) & 0xBF);
+       /* Set Conversion rate to 1/sec (this can be tinkered with) */
+       adm1021_write_value(client, ADM1021_REG_CONV_RATE_W, 0x04);
+}
+
+static int adm1021_detach_client(struct i2c_client *client)
+{
+       int err;
+
+       i2c_deregister_entry(((struct adm1021_data *) (client->data))->
+                                sysctl_id);
+
+       if ((err = i2c_detach_client(client))) {
+               printk
+                   ("adm1021.o: Client deregistration failed, client not detached.\n");
+               return err;
+       }
+
+       kfree(client->data);
+
+       return 0;
+}
+
+
+/* All registers are byte-sized */
+static int adm1021_read_value(struct i2c_client *client, u8 reg)
+{
+       return i2c_smbus_read_byte_data(client, reg);
+}
+
+/* only update value if read succeeded; set fail bit if failed */
+static int adm1021_rd_good(u8 *val, struct i2c_client *client, u8 reg, u8 mask)
+{
+       int i;
+       struct adm1021_data *data = client->data;
+
+       i = i2c_smbus_read_byte_data(client, reg);
+       if (i < 0) {
+               data->fail |= mask;
+               return i;
+       }
+       *val = i;
+       return 0;
+}
+
+static int adm1021_write_value(struct i2c_client *client, u8 reg, u16 value)
+{
+       if (read_only > 0)
+               return 0;
+
+       return i2c_smbus_write_byte_data(client, reg, value);
+}
+
+static void adm1021_update_client(struct i2c_client *client)
+{
+       struct adm1021_data *data = client->data;
+
+       down(&data->update_lock);
+
+       if ((jiffies - data->last_updated > HZ + HZ / 2) ||
+           (jiffies < data->last_updated) || !data->valid) {
+
+#ifdef DEBUG
+               printk("Starting adm1021 update\n");
+#endif
+
+               data->fail = 0;
+               adm1021_rd_good(&(data->temp), client, ADM1021_REG_TEMP,
+                               ADM1021_ALARM_TEMP);
+               adm1021_rd_good(&(data->temp_os), client, ADM1021_REG_TOS_R,
+                               ADM1021_ALARM_TEMP);
+               adm1021_rd_good(&(data->temp_hyst), client,
+                               ADM1021_REG_THYST_R, ADM1021_ALARM_TEMP);
+               adm1021_rd_good(&(data->remote_temp), client,
+                               ADM1021_REG_REMOTE_TEMP, ADM1021_ALARM_RTEMP);
+               adm1021_rd_good(&(data->remote_temp_os), client,
+                               ADM1021_REG_REMOTE_TOS_R, ADM1021_ALARM_RTEMP);
+               adm1021_rd_good(&(data->remote_temp_hyst), client,
+                               ADM1021_REG_REMOTE_THYST_R,
+                               ADM1021_ALARM_RTEMP);
+               data->alarms = ADM1021_ALARM_ALL;
+               if (!adm1021_rd_good(&(data->alarms), client,
+                                    ADM1021_REG_STATUS, 0))
+                       data->alarms &= ADM1021_ALARM_ALL;
+               if (data->type == adm1021)
+                       adm1021_rd_good(&(data->die_code), client,
+                                       ADM1021_REG_DIE_CODE, 0);
+               if (data->type == adm1023) {
+                       adm1021_rd_good(&(data->remote_temp_prec), client,
+                                       ADM1021_REG_REM_TEMP_PREC,
+                                       ADM1021_ALARM_TEMP);
+                       adm1021_rd_good(&(data->remote_temp_os_prec), client,
+                                       ADM1021_REG_REM_TOS_PREC,
+                                       ADM1021_ALARM_RTEMP);
+                       adm1021_rd_good(&(data->remote_temp_hyst_prec), client,
+                                       ADM1021_REG_REM_THYST_PREC,
+                                       ADM1021_ALARM_RTEMP);
+                       adm1021_rd_good(&(data->remote_temp_offset), client,
+                                       ADM1021_REG_REM_OFFSET,
+                                       ADM1021_ALARM_RTEMP);
+                       adm1021_rd_good(&(data->remote_temp_offset_prec),
+                                       client, ADM1021_REG_REM_OFFSET_PREC,
+                                       ADM1021_ALARM_RTEMP);
+               }
+               data->last_updated = jiffies;
+               data->valid = 1;
+       }
+
+       up(&data->update_lock);
+}
+
+
+void adm1021_temp(struct i2c_client *client, int operation, int ctl_name,
+                 int *nrels_mag, long *results)
+{
+       struct adm1021_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm1021_update_client(client);
+               results[0] = TEMP_FROM_REG(data->temp_os);
+               results[1] = TEMP_FROM_REG(data->temp_hyst);
+               results[2] = TEMP_FROM_REG(data->temp);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->temp_os = TEMP_TO_REG(results[0]);
+                       adm1021_write_value(client, ADM1021_REG_TOS_W,
+                                           data->temp_os);
+               }
+               if (*nrels_mag >= 2) {
+                       data->temp_hyst = TEMP_TO_REG(results[1]);
+                       adm1021_write_value(client, ADM1021_REG_THYST_W,
+                                           data->temp_hyst);
+               }
+       }
+}
+
+void adm1021_remote_temp(struct i2c_client *client, int operation,
+                        int ctl_name, int *nrels_mag, long *results)
+{
+       struct adm1021_data *data = client->data;
+       int prec = 0;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               if (data->type == adm1023) { *nrels_mag = 3; }
+                 else { *nrels_mag = 0; }
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm1021_update_client(client);
+               results[0] = TEMP_FROM_REG(data->remote_temp_os);
+               results[1] = TEMP_FROM_REG(data->remote_temp_hyst);
+               results[2] = TEMP_FROM_REG(data->remote_temp);
+               if (data->type == adm1023) {
+                 results[0]=results[0]*1000 + 
+                  ((data->remote_temp_os_prec >> 5) * 125);
+                 results[1]=results[1]*1000 + 
+                  ((data->remote_temp_hyst_prec >> 5) * 125);
+                 results[2]=(TEMP_FROM_REG(data->remote_temp_offset)*1000) + 
+                   ((data->remote_temp_offset_prec >> 5) * 125);
+                 results[3]=TEMP_FROM_REG(data->remote_temp)*1000 + 
+                  ((data->remote_temp_prec >> 5) * 125);
+                 *nrels_mag = 4;
+               } else {
+                 *nrels_mag = 3;
+               }
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       if (data->type == adm1023) {
+                         prec=((results[0]-((results[0]/1000)*1000))/125)<<5;
+                         adm1021_write_value(client,
+                                            ADM1021_REG_REM_TOS_PREC,
+                                            prec);
+                         results[0]=results[0]/1000;
+                         data->remote_temp_os_prec=prec;
+                       }
+                       data->remote_temp_os = TEMP_TO_REG(results[0]);
+                       adm1021_write_value(client,
+                                           ADM1021_REG_REMOTE_TOS_W,
+                                           data->remote_temp_os);
+               }
+               if (*nrels_mag >= 2) {
+                       if (data->type == adm1023) {
+                         prec=((results[1]-((results[1]/1000)*1000))/125)<<5;
+                         adm1021_write_value(client,
+                                            ADM1021_REG_REM_THYST_PREC,
+                                            prec);
+                         results[1]=results[1]/1000;
+                         data->remote_temp_hyst_prec=prec;
+                       }
+                       data->remote_temp_hyst = TEMP_TO_REG(results[1]);
+                       adm1021_write_value(client,
+                                           ADM1021_REG_REMOTE_THYST_W,
+                                           data->remote_temp_hyst);
+               }
+               if (*nrels_mag >= 3) {
+                       if (data->type == adm1023) {
+                         prec=((results[2]-((results[2]/1000)*1000))/125)<<5;
+                         adm1021_write_value(client,
+                                            ADM1021_REG_REM_OFFSET_PREC,
+                                            prec);
+                         results[2]=results[2]/1000;
+                         data->remote_temp_offset_prec=prec;
+                         data->remote_temp_offset=results[2];
+                         adm1021_write_value(client,
+                                            ADM1021_REG_REM_OFFSET,
+                                            data->remote_temp_offset);
+                       }
+               }
+       }
+}
+
+void adm1021_die_code(struct i2c_client *client, int operation,
+                     int ctl_name, int *nrels_mag, long *results)
+{
+       struct adm1021_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm1021_update_client(client);
+               results[0] = data->die_code;
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               /* Can't write to it */
+       }
+}
+
+void adm1021_alarms(struct i2c_client *client, int operation, int ctl_name,
+                   int *nrels_mag, long *results)
+{
+       struct adm1021_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm1021_update_client(client);
+               results[0] = data->alarms | data->fail;
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               /* Can't write to it */
+       }
+}
+
+static int __init sm_adm1021_init(void)
+{
+       printk(KERN_INFO "adm1021.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       return i2c_add_driver(&adm1021_driver);
+}
+
+static void __exit sm_adm1021_exit(void)
+{
+       i2c_del_driver(&adm1021_driver);
+}
+
+MODULE_AUTHOR
+    ("Frodo Looijaard <frodol@dds.nl> and Philip Edelbrock <phil@netroedge.com>");
+MODULE_DESCRIPTION("adm1021 driver");
+MODULE_LICENSE("GPL");
+
+MODULE_PARM(read_only, "i");
+MODULE_PARM_DESC(read_only, "Don't set any values, read only mode");
+
+module_init(sm_adm1021_init)
+module_exit(sm_adm1021_exit)
--- linux-old/drivers/sensors/adm1024.c Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/adm1024.c     Mon Dec 13 20:18:43 2004
@@ -0,0 +1,782 @@
+/*
+    adm1024.c - Part of lm_sensors, Linux kernel modules for hardware
+             monitoring
+    Add by Ken Bowley <ken@opnix.com> from the adm1025.c written by
+    Gordon Wu <gwu@esoft.com> and from adm9240.c written by
+    Copyright (c) 1999  Frodo Looijaard <frodol@dds.nl>
+    and Philip Edelbrock <phil@netroedge.com>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or 
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/* Supports the Analog Devices ADM1024. See doc/chips/adm1024 for details */
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = { SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { 0x2c, 0x2e, SENSORS_I2C_END };
+static unsigned int normal_isa[] = { SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+/* Insmod parameters */
+SENSORS_INSMOD_1(adm1024);
+
+/* Many ADM1024 constants specified below */
+
+#define ADM1024_REG_IN_MAX(nr) (0x2b + (nr) * 2)
+#define ADM1024_REG_IN_MIN(nr) (0x2c + (nr) * 2)
+#define ADM1024_REG_IN(nr) (0x20 + (nr))
+
+/* The ADM1024 registers */
+#define ADM1024_REG_INT_TEMP_TRIP_SET 0x13
+#define ADM1024_REG_EXT_TEMP_TRIP_SET 0x14
+#define ADM1024_REG_TEST 0x15
+#define ADM1024_REG_CHANNEL_MODE 0x16
+#define ADM1024_REG_INT_TEMP_TRIP 0x17 /* read only */
+#define ADM1024_REG_EXT_TEMP_TRIP 0x18 /* read only */
+#define ADM1024_REG_ANALOG_OUT 0x19
+#define ADM1024_REG_AIN1_LOW_LIMIT 0x1A
+#define ADM1024_REG_AIN2_LOW_LIMIT 0x1B
+/* These are all read-only */
+#define ADM1024_REG_2_5V 0x20  /* 2.5V Measured Value/EXT Temp 2 */
+#define ADM1024_REG_VCCP1 0x21
+#define ADM1024_REG_3_3V 0x22  /* VCC Measured Value */
+#define ADM1024_REG_5V 0x23
+#define ADM1024_REG_12V 0x24
+#define ADM1024_REG_VCCP2 0x25
+#define ADM1024_REG_EXT_TEMP1 0x26
+#define ADM1024_REG_TEMP 0x27
+#define ADM1024_REG_FAN1 0x28  /* FAN1/AIN1 Value */
+#define ADM1024_REG_FAN2 0x29  /* FAN2/AIN2 Value */
+#define ADM1024_REG_COMPANY_ID 0x3E    /* 0x41 for ADM1024 */
+#define ADM1024_REG_DIE_REV 0x3F
+/* These are read/write */
+#define ADM1024_REG_2_5V_HIGH 0x2B     /* 2.5V/Ext Temp2 High Limit */
+#define ADM1024_REG_2_5V_LOW 0x2C      /* 2.5V/Ext Temp2 Low Limit */
+#define ADM1024_REG_VCCP1_HIGH 0x2D
+#define ADM1024_REG_VCCP1_LOW 0x2E
+#define ADM1024_REG_3_3V_HIGH 0x2F     /* VCC High Limit */
+#define ADM1024_REG_3_3V_LOW 0x30      /* VCC Low Limit */
+#define ADM1024_REG_5V_HIGH 0x31
+#define ADM1024_REG_5V_LOW 0x32
+#define ADM1024_REG_12V_HIGH 0x33
+#define ADM1024_REG_12V_LOW 0x34
+#define ADM1024_REG_VCCP2_HIGH 0x35
+#define ADM1024_REG_VCCP2_LOW 0x36
+#define ADM1024_REG_EXT_TEMP1_HIGH 0x37
+#define ADM1024_REG_EXT_TEMP1_LOW 0x38
+#define ADM1024_REG_TOS 0x39
+#define ADM1024_REG_THYST 0x3A
+#define ADM1024_REG_FAN1_MIN 0x3B
+#define ADM1024_REG_FAN2_MIN 0x3C
+
+#define ADM1024_REG_CONFIG 0x40
+#define ADM1024_REG_INT1_STAT 0x41
+#define ADM1024_REG_INT2_STAT 0x42
+#define ADM1024_REG_INT1_MASK 0x43
+#define ADM1024_REG_INT2_MASK 0x44
+
+#define ADM1024_REG_CHASSIS_CLEAR 0x46
+#define ADM1024_REG_VID_FAN_DIV 0x47
+#define ADM1024_REG_I2C_ADDR 0x48
+#define ADM1024_REG_VID4 0x49
+#define ADM1024_REG_CONFIG2 0x4A
+#define ADM1024_REG_TEMP_CONFIG 0x4B
+#define ADM1024_REG_EXTMODE1 0x4C      /* Interupt Status Register Mirror No. 1 */
+#define ADM1024_REG_EXTMODE2 0x4D      /* Interupt Status Register Mirror No. 2 */
+
+/* Conversions. Rounding and limit checking is only done on the TO_REG
+   variants. Note that you should be a bit careful with which arguments
+   these macros are called: arguments may be evaluated more than once.
+   Fixing this is just not worth it. */
+#define IN_TO_REG(val,nr) (SENSORS_LIMIT(((val) & 0xff),0,255))
+#define IN_FROM_REG(val,nr) (val)
+
+static inline u8 FAN_TO_REG(long rpm, int div)
+{
+       if (rpm == 0)
+               return 255;
+       rpm = SENSORS_LIMIT(rpm, 1, 1000000);
+       return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1,
+                            254);
+}
+
+#define FAN_FROM_REG(val,div) ((val)==0?-1:\
+                               (val)==255?0:1350000/((div)*(val)))
+
+#define TEMP_FROM_REG(temp) \
+   ((temp)<256?((((temp)&0x1fe) >> 1) * 10)      + ((temp) & 1) * 5:  \
+               ((((temp)&0x1fe) >> 1) -255) * 10 - ((temp) & 1) * 5)  \
+
+#define EXT_TEMP_FROM_REG(temp) (((temp)>0x80?(temp)-0x100:(temp))*10)
+   
+
+#define TEMP_LIMIT_FROM_REG(val) (((val)>0x80?(val)-0x100:(val))*10)
+
+#define TEMP_LIMIT_TO_REG(val) SENSORS_LIMIT(((val)<0?(((val)-5)/10):\
+                                                      ((val)+5)/10), \
+                                             0,255)
+
+#define ALARMS_FROM_REG(val) (val)
+
+#define DIV_FROM_REG(val) (1 << (val))
+#define DIV_TO_REG(val) ((val)==1?0:((val)==8?3:((val)==4?2:1)))
+
+#define VID_FROM_REG(val) ((val)==0x1f?0:(val)>=0x10?510-(val)*10:\
+                           205-(val)*5)
+
+/* For each registered ADM1024, we need to keep some data in memory. That
+   data is pointed to by adm1024_list[NR]->data. The structure itself is
+   dynamically allocated, at the same time when a new adm1024 client is
+   allocated. */
+struct adm1024_data {
+       struct i2c_client client;
+       int sysctl_id;
+       enum chips type;
+
+       struct semaphore update_lock;
+       char valid;             /* !=0 if following fields are valid */
+       unsigned long last_updated;     /* In jiffies */
+
+       u8 in[6];               /* Register value */
+       u8 in_max[6];           /* Register value */
+       u8 in_min[6];           /* Register value */
+       u8 fan[2];              /* Register value */
+       u8 fan_min[2];          /* Register value */
+       u8 fan_div[2];          /* Register encoding, shifted right */
+       int temp;               /* Temp, shifted right */
+       u8 temp_os_max;         /* Register value */
+       u8 temp_os_hyst;        /* Register value */
+       int temp1;              /* Ext Temp 1 */
+       u8 temp1_os_max;
+       u8 temp1_os_hyst;
+       int temp2;              /* Ext Temp 2 */
+       u8 temp2_os_max;
+       u8 temp2_os_hyst;
+       u16 alarms;             /* Register encoding, combined */
+       u8 analog_out;          /* Register value */
+       u8 vid;                 /* Register value combined */
+};
+
+
+
+static int adm1024_attach_adapter(struct i2c_adapter *adapter);
+static int adm1024_detect(struct i2c_adapter *adapter, int address,
+                         unsigned short flags, int kind);
+static int adm1024_detach_client(struct i2c_client *client);
+
+static int adm1024_read_value(struct i2c_client *client, u8 register);
+static int adm1024_write_value(struct i2c_client *client, u8 register,
+                              u8 value);
+static void adm1024_update_client(struct i2c_client *client);
+static void adm1024_init_client(struct i2c_client *client);
+
+
+static void adm1024_in(struct i2c_client *client, int operation,
+                      int ctl_name, int *nrels_mag, long *results);
+static void adm1024_fan(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void adm1024_temp(struct i2c_client *client, int operation,
+                        int ctl_name, int *nrels_mag, long *results);
+static void adm1024_temp1(struct i2c_client *client, int operation,
+                        int ctl_name, int *nrels_mag, long *results);
+static void adm1024_temp2(struct i2c_client *client, int operation,
+                        int ctl_name, int *nrels_mag, long *results);
+static void adm1024_alarms(struct i2c_client *client, int operation,
+                          int ctl_name, int *nrels_mag, long *results);
+static void adm1024_fan_div(struct i2c_client *client, int operation,
+                           int ctl_name, int *nrels_mag, long *results);
+static void adm1024_analog_out(struct i2c_client *client, int operation,
+                              int ctl_name, int *nrels_mag,
+                              long *results);
+static void adm1024_vid(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+
+static int adm1024_id = 0;
+
+static struct i2c_driver adm1024_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "ADM1024 sensor driver",
+       .id             = I2C_DRIVERID_ADM1024,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = adm1024_attach_adapter,
+       .detach_client  = adm1024_detach_client,
+};
+
+/* The /proc/sys entries */
+/* -- SENSORS SYSCTL START -- */
+
+#define ADM1024_SYSCTL_IN0 1000        /* Volts * 100 */
+#define ADM1024_SYSCTL_IN1 1001
+#define ADM1024_SYSCTL_IN2 1002
+#define ADM1024_SYSCTL_IN3 1003
+#define ADM1024_SYSCTL_IN4 1004
+#define ADM1024_SYSCTL_IN5 1005
+#define ADM1024_SYSCTL_FAN1 1101       /* Rotations/min */
+#define ADM1024_SYSCTL_FAN2 1102
+#define ADM1024_SYSCTL_TEMP 1250       /* Degrees Celcius * 100 */
+#define ADM1024_SYSCTL_TEMP1 1290      /* Degrees Celcius */
+#define ADM1024_SYSCTL_TEMP2 1295      /* Degrees Celcius */
+#define ADM1024_SYSCTL_FAN_DIV 2000    /* 1, 2, 4 or 8 */
+#define ADM1024_SYSCTL_ALARMS 2001     /* bitvector */
+#define ADM1024_SYSCTL_ANALOG_OUT 2002
+#define ADM1024_SYSCTL_VID 2003
+
+#define ADM1024_ALARM_IN0 0x0001
+#define ADM1024_ALARM_IN1 0x0002
+#define ADM1024_ALARM_IN2 0x0004
+#define ADM1024_ALARM_IN3 0x0008
+#define ADM1024_ALARM_IN4 0x0100
+#define ADM1024_ALARM_IN5 0x0200
+#define ADM1024_ALARM_FAN1 0x0040
+#define ADM1024_ALARM_FAN2 0x0080
+#define ADM1024_ALARM_TEMP 0x0010
+#define ADM1024_ALARM_TEMP1 0x0020
+#define ADM1024_ALARM_TEMP2 0x0001
+#define ADM1024_ALARM_CHAS 0x1000
+
+/* -- SENSORS SYSCTL END -- */
+
+/* These files are created for each detected ADM1024. This is just a template;
+   though at first sight, you might think we could use a statically
+   allocated list, we need some way to get back to the parent - which
+   is done through one of the 'extra' fields which are initialized 
+   when a new copy is allocated. */
+static ctl_table adm1024_dir_table_template[] = {
+       {ADM1024_SYSCTL_IN0, "in0", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm1024_in},
+       {ADM1024_SYSCTL_IN1, "in1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm1024_in},
+       {ADM1024_SYSCTL_IN2, "in2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm1024_in},
+       {ADM1024_SYSCTL_IN3, "in3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm1024_in},
+       {ADM1024_SYSCTL_IN4, "in4", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm1024_in},
+       {ADM1024_SYSCTL_IN5, "in5", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm1024_in},
+       {ADM1024_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm1024_fan},
+       {ADM1024_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm1024_fan},
+       {ADM1024_SYSCTL_TEMP, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm1024_temp},
+       {ADM1024_SYSCTL_TEMP1, "temp2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm1024_temp1},
+       {ADM1024_SYSCTL_TEMP2, "temp3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm1024_temp2},
+       {ADM1024_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm1024_fan_div},
+       {ADM1024_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm1024_alarms},
+       {ADM1024_SYSCTL_ANALOG_OUT, "analog_out", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm1024_analog_out},
+       {ADM1024_SYSCTL_VID, "vid", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm1024_vid},
+       {0}
+};
+
+static int adm1024_attach_adapter(struct i2c_adapter *adapter)
+{
+       return i2c_detect(adapter, &addr_data, adm1024_detect);
+}
+
+static int adm1024_detect(struct i2c_adapter *adapter, int address,
+                         unsigned short flags, int kind)
+{
+       int i;
+       struct i2c_client *new_client;
+       struct adm1024_data *data;
+       int err = 0;
+       const char *type_name = "";
+       const char *client_name = "";
+
+       /* Make sure we aren't probing the ISA bus!! This is just a safety check
+          at this moment; i2c_detect really won't call us. */
+#ifdef DEBUG
+       if (i2c_is_isa_adapter(adapter)) {
+               printk
+                   ("adm1024.o: adm1024_detect called for an ISA bus adapter?!?\n");
+               return 0;
+       }
+#endif
+
+       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
+               goto ERROR0;
+
+       /* OK. For now, we presume we have a valid client. We now create the
+          client structure, even though we cannot fill it completely yet.
+          But it allows us to access adm1024_{read,write}_value. */
+
+       if (!(data = kmalloc(sizeof(struct adm1024_data), GFP_KERNEL))) {
+               err = -ENOMEM;
+               goto ERROR0;
+       }
+
+       new_client = &data->client;
+       new_client->addr = address;
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &adm1024_driver;
+       new_client->flags = 0;
+
+       /* Now, we do the remaining detection. */
+
+       if (kind < 0) {
+               if((adm1024_read_value(new_client, ADM1024_REG_CONFIG) & 0x80) != 0x00)
+                       goto ERROR1;
+       }
+
+       /* Determine the chip type. */
+       if (kind <= 0) {
+               i = adm1024_read_value(new_client, ADM1024_REG_COMPANY_ID);
+               if (i == 0x41)
+                       kind = adm1024;
+               else {
+                       if (kind == 0)
+                               printk
+                                   ("adm1024.o: Ignoring 'force' parameter for unknown chip at "
+                                    "adapter %d, address 0x%02x\n",
+                                    i2c_adapter_id(adapter), address);
+                       goto ERROR1;
+               }
+       }
+
+       if (kind == adm1024) {
+               type_name = "adm1024";
+               client_name = "ADM1024 chip";
+       } else {
+#ifdef DEBUG
+               printk("adm1024.o: Internal error: unknown kind (%d)?!?",
+                      kind);
+#endif
+               goto ERROR1;
+       }
+
+       /* Fill in the remaining client fields and put it into the global list */
+       strcpy(new_client->name, client_name);
+       data->type = kind;
+
+       new_client->id = adm1024_id++;
+       data->valid = 0;
+       init_MUTEX(&data->update_lock);
+
+       /* Tell the I2C layer a new client has arrived */
+       if ((err = i2c_attach_client(new_client)))
+               goto ERROR3;
+
+       /* Register a new directory entry with module sensors */
+       if ((i = i2c_register_entry(new_client,
+                                       type_name,
+                                       adm1024_dir_table_template)) < 0) {
+               err = i;
+               goto ERROR4;
+       }
+       data->sysctl_id = i;
+
+       /* Initialize the ADM1024 chip */
+       adm1024_init_client(new_client);
+       return 0;
+
+/* OK, this is not exactly good programming practice, usually. But it is
+   very code-efficient in this case. */
+
+      ERROR4:
+       i2c_detach_client(new_client);
+      ERROR3:
+      ERROR1:
+       kfree(data);
+      ERROR0:
+       return err;
+}
+
+static int adm1024_detach_client(struct i2c_client *client)
+{
+       int err;
+
+       i2c_deregister_entry(((struct adm1024_data *) (client->data))->
+                                sysctl_id);
+
+       if ((err = i2c_detach_client(client))) {
+               printk
+                   ("adm1024.o: Client deregistration failed, client not detached.\n");
+               return err;
+       }
+
+       kfree(client->data);
+
+       return 0;
+}
+
+static int adm1024_read_value(struct i2c_client *client, u8 reg)
+{
+       return 0xFF & i2c_smbus_read_byte_data(client, reg);
+}
+
+static int adm1024_write_value(struct i2c_client *client, u8 reg, u8 value)
+{
+       return i2c_smbus_write_byte_data(client, reg, value);
+}
+
+static void adm1024_init_client(struct i2c_client *client)
+{
+       /* Enable temperature channel 2 */
+       adm1024_write_value(client, ADM1024_REG_CHANNEL_MODE, adm1024_read_value(client, ADM1024_REG_CHANNEL_MODE) | 0x04);
+
+       /* Start monitoring */
+       adm1024_write_value(client, ADM1024_REG_CONFIG, 0x07);
+}
+
+static void adm1024_update_client(struct i2c_client *client)
+{
+       struct adm1024_data *data = client->data;
+       u8 i;
+
+       down(&data->update_lock);
+
+       if (
+           (jiffies - data->last_updated >
+            (data->type == adm1024 ? HZ / 2 : HZ * 2))
+           || (jiffies < data->last_updated) || !data->valid) {
+
+#ifdef DEBUG
+               printk("Starting adm1024 update\n");
+#endif
+               for (i = 0; i <= 5; i++) {
+                       data->in[i] =
+                           adm1024_read_value(client, ADM1024_REG_IN(i));
+                       data->in_min[i] =
+                           adm1024_read_value(client,
+                                              ADM1024_REG_IN_MIN(i));
+                       data->in_max[i] =
+                           adm1024_read_value(client,
+                                              ADM1024_REG_IN_MAX(i));
+               }
+               data->fan[0] =
+                   adm1024_read_value(client, ADM1024_REG_FAN1);
+               data->fan_min[0] =
+                   adm1024_read_value(client, ADM1024_REG_FAN1_MIN);
+               data->fan[1] =
+                   adm1024_read_value(client, ADM1024_REG_FAN2);
+               data->fan_min[1] =
+                   adm1024_read_value(client, ADM1024_REG_FAN2_MIN);
+               data->temp =
+                   (adm1024_read_value(client, ADM1024_REG_TEMP) << 1) +
+                   ((adm1024_read_value
+                     (client, ADM1024_REG_TEMP_CONFIG) & 0x80) >> 7);
+               data->temp_os_max =
+                   adm1024_read_value(client, ADM1024_REG_TOS);
+               data->temp_os_hyst =
+                   adm1024_read_value(client, ADM1024_REG_THYST);
+               data->temp1 =
+                   adm1024_read_value(client, ADM1024_REG_EXT_TEMP1);
+               data->temp1_os_max =
+                   adm1024_read_value(client, ADM1024_REG_EXT_TEMP1_HIGH);
+               data->temp1_os_hyst =
+                   adm1024_read_value(client, ADM1024_REG_EXT_TEMP1_LOW);
+               data->temp2 =
+                   adm1024_read_value(client, ADM1024_REG_2_5V);
+               data->temp2_os_max =
+                   adm1024_read_value(client, ADM1024_REG_2_5V_HIGH);
+               data->temp2_os_hyst =
+                   adm1024_read_value(client, ADM1024_REG_2_5V_LOW);
+
+               i = adm1024_read_value(client, ADM1024_REG_VID_FAN_DIV);
+               data->fan_div[0] = (i >> 4) & 0x03;
+               data->fan_div[1] = (i >> 6) & 0x03;
+               data->vid = i & 0x0f;
+               data->vid |=
+                   (adm1024_read_value(client, ADM1024_REG_VID4) & 0x01)
+                   << 4;
+
+               data->alarms =
+                   adm1024_read_value(client,
+                                      ADM1024_REG_INT1_STAT) +
+                   (adm1024_read_value(client, ADM1024_REG_INT2_STAT) <<
+                    8);
+               data->analog_out =
+                   adm1024_read_value(client, ADM1024_REG_ANALOG_OUT);
+               data->last_updated = jiffies;
+               data->valid = 1;
+       }
+
+       up(&data->update_lock);
+}
+
+
+/* The next few functions are the call-back functions of the /proc/sys and
+   sysctl files. Which function is used is defined in the ctl_table in
+   the extra1 field.
+   Each function must return the magnitude (power of 10 to divide the date
+   with) if it is called with operation==SENSORS_PROC_REAL_INFO. It must
+   put a maximum of *nrels elements in results reflecting the data of this
+   file, and set *nrels to the number it actually put in it, if operation==
+   SENSORS_PROC_REAL_READ. Finally, it must get upto *nrels elements from
+   results and write them to the chip, if operations==SENSORS_PROC_REAL_WRITE.
+   Note that on SENSORS_PROC_REAL_READ, I do not check whether results is
+   large enough (by checking the incoming value of *nrels). This is not very
+   good practice, but as long as you put less than about 5 values in results,
+   you can assume it is large enough. */
+void adm1024_in(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+
+       int scales[6] = { 250, 225, 330, 500, 1200, 270 };
+
+       struct adm1024_data *data = client->data;
+       int nr = ctl_name - ADM1024_SYSCTL_IN0;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 2;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm1024_update_client(client);
+               results[0] =
+                   IN_FROM_REG(data->in_min[nr], nr) * scales[nr] / 192;
+               results[1] =
+                   IN_FROM_REG(data->in_max[nr], nr) * scales[nr] / 192;
+               results[2] =
+                   IN_FROM_REG(data->in[nr], nr) * scales[nr] / 192;
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->in_min[nr] =
+                           IN_TO_REG((results[0] * 192) / scales[nr], nr);
+                       adm1024_write_value(client, ADM1024_REG_IN_MIN(nr),
+                                           data->in_min[nr]);
+               }
+               if (*nrels_mag >= 2) {
+                       data->in_max[nr] =
+                           IN_TO_REG((results[1] * 192) / scales[nr], nr);
+                       adm1024_write_value(client, ADM1024_REG_IN_MAX(nr),
+                                           data->in_max[nr]);
+               }
+       }
+}
+
+void adm1024_fan(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct adm1024_data *data = client->data;
+       int nr = ctl_name - ADM1024_SYSCTL_FAN1 + 1;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm1024_update_client(client);
+               results[0] = FAN_FROM_REG(data->fan_min[nr - 1],
+                                         DIV_FROM_REG(data->
+                                                      fan_div[nr - 1]));
+               results[1] =
+                   FAN_FROM_REG(data->fan[nr - 1],
+                                DIV_FROM_REG(data->fan_div[nr - 1]));
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->fan_min[nr - 1] = FAN_TO_REG(results[0],
+                                                          DIV_FROM_REG
+                                                          (data->
+                                                           fan_div[nr -
+                                                                   1]));
+                       adm1024_write_value(client,
+                                           nr ==
+                                           1 ? ADM1024_REG_FAN1_MIN :
+                                           ADM1024_REG_FAN2_MIN,
+                                           data->fan_min[nr - 1]);
+               }
+       }
+}
+
+
+void adm1024_temp(struct i2c_client *client, int operation, int ctl_name,
+                 int *nrels_mag, long *results)
+{
+       struct adm1024_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm1024_update_client(client);
+               results[0] = TEMP_LIMIT_FROM_REG(data->temp_os_max);
+               results[1] = TEMP_LIMIT_FROM_REG(data->temp_os_hyst);
+               results[2] = TEMP_FROM_REG(data->temp);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->temp_os_max = TEMP_LIMIT_TO_REG(results[0]);
+                       adm1024_write_value(client, ADM1024_REG_TOS,
+                                           data->temp_os_max);
+               }
+               if (*nrels_mag >= 2) {
+                       data->temp_os_hyst = TEMP_LIMIT_TO_REG(results[1]);
+                       adm1024_write_value(client, ADM1024_REG_THYST,
+                                           data->temp_os_hyst);
+               }
+       }
+}
+
+void adm1024_temp1(struct i2c_client *client, int operation, int ctl_name,
+                 int *nrels_mag, long *results)
+{
+       struct adm1024_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm1024_update_client(client);
+               results[0] = TEMP_LIMIT_FROM_REG(data->temp1_os_max);
+               results[1] = TEMP_LIMIT_FROM_REG(data->temp1_os_hyst);
+               results[2] = EXT_TEMP_FROM_REG(data->temp1);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->temp1_os_max = TEMP_LIMIT_TO_REG(results[0]);
+                       adm1024_write_value(client, ADM1024_REG_EXT_TEMP1_HIGH,
+                                           data->temp1_os_max);
+               }
+               if (*nrels_mag >= 2) {
+                       data->temp1_os_hyst = TEMP_LIMIT_TO_REG(results[1]);
+                       adm1024_write_value(client, ADM1024_REG_EXT_TEMP1_LOW,
+                                           data->temp1_os_hyst);
+               }
+       }
+}
+
+void adm1024_temp2(struct i2c_client *client, int operation, int ctl_name,
+                 int *nrels_mag, long *results)
+{
+       struct adm1024_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm1024_update_client(client);
+               results[0] = TEMP_LIMIT_FROM_REG(data->temp2_os_max);
+               results[1] = TEMP_LIMIT_FROM_REG(data->temp2_os_hyst);
+               results[2] = EXT_TEMP_FROM_REG(data->temp2);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->temp2_os_max = TEMP_LIMIT_TO_REG(results[0]);
+                       adm1024_write_value(client, ADM1024_REG_2_5V_HIGH,
+                                           data->temp2_os_max);
+               }
+               if (*nrels_mag >= 2) {
+                       data->temp2_os_hyst = TEMP_LIMIT_TO_REG(results[1]);
+                       adm1024_write_value(client, ADM1024_REG_2_5V_LOW,
+                                           data->temp2_os_hyst);
+               }
+       }
+}
+
+void adm1024_alarms(struct i2c_client *client, int operation, int ctl_name,
+                   int *nrels_mag, long *results)
+{
+       struct adm1024_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm1024_update_client(client);
+               results[0] = ALARMS_FROM_REG(data->alarms);
+               *nrels_mag = 1;
+       }
+}
+
+void adm1024_fan_div(struct i2c_client *client, int operation,
+                    int ctl_name, int *nrels_mag, long *results)
+{
+       struct adm1024_data *data = client->data;
+       int old;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm1024_update_client(client);
+               results[0] = DIV_FROM_REG(data->fan_div[0]);
+               results[1] = DIV_FROM_REG(data->fan_div[1]);
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               old = adm1024_read_value(client, ADM1024_REG_VID_FAN_DIV);
+               if (*nrels_mag >= 2) {
+                       data->fan_div[1] = DIV_TO_REG(results[1]);
+                       old = (old & 0x3f) | (data->fan_div[1] << 6);
+               }
+               if (*nrels_mag >= 1) {
+                       data->fan_div[0] = DIV_TO_REG(results[0]);
+                       old = (old & 0xcf) | (data->fan_div[0] << 4);
+                       adm1024_write_value(client,
+                                           ADM1024_REG_VID_FAN_DIV, old);
+               }
+       }
+}
+
+void adm1024_analog_out(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results)
+{
+       struct adm1024_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm1024_update_client(client);
+               results[0] = data->analog_out;
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->analog_out = results[0];
+                       adm1024_write_value(client, ADM1024_REG_ANALOG_OUT,
+                                           data->analog_out);
+               }
+       }
+}
+
+void adm1024_vid(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct adm1024_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 2;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm1024_update_client(client);
+               results[0] = VID_FROM_REG(data->vid);
+               *nrels_mag = 1;
+       }
+}
+
+static int __init sm_adm1024_init(void)
+{
+       printk("adm1024.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       return i2c_add_driver(&adm1024_driver);
+}
+
+static void __exit sm_adm1024_exit(void)
+{
+       i2c_del_driver(&adm1024_driver);
+}
+
+
+
+MODULE_AUTHOR
+    ("Frodo Looijaard <frodol@dds.nl> and Philip Edelbrock <phil@netroedge.com>");
+MODULE_DESCRIPTION("ADM1024 driver");
+
+MODULE_LICENSE("GPL");
+
+module_init(sm_adm1024_init);
+module_exit(sm_adm1024_exit);
--- linux-old/drivers/sensors/adm1025.c Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/adm1025.c     Mon Dec 13 20:18:43 2004
@@ -0,0 +1,594 @@
+/*
+    adm1025.c - Part of lm_sensors, Linux kernel modules for hardware
+               monitoring
+    Copyright (c) 2000 Chen-Yuan Wu <gwu@esoft.com>
+    Copyright (c) 2003-2004 Jean Delvare <khali@linux-fr.org>
+
+    Based on the adm9240 driver.
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or 
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/* Supports the Analog Devices ADM1025 and the Philips NE1619.
+   See doc/chips/adm1025 for details */
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+#include <linux/sensors_vid.h>
+
+MODULE_LICENSE("GPL");
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = { SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { 0x2c, 0x2e, SENSORS_I2C_END };
+static unsigned int normal_isa[] = { SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+/* Insmod parameters */
+SENSORS_INSMOD_2(adm1025, ne1619);
+
+/* Many ADM1025 constants specified below */
+
+
+/* The ADM1025 registers */
+
+/* These are all read-only */
+#define ADM1025_REG_2_5V        0x20 /* not used directly, see   */
+#define ADM1025_REG_VCCP1       0x21 /* ADM1025_REG_IN(nr) below */
+#define ADM1025_REG_3_3V        0x22
+#define ADM1025_REG_5V          0x23
+#define ADM1025_REG_12V         0x24
+#define ADM1025_REG_VCC         0x25
+
+#define ADM1025_REG_RTEMP       0x26 /* not used directly, see     */
+#define ADM1025_REG_LTEMP       0x27 /* ADM1025_REG_TEMP(nr) below */
+
+#define ADM1025_REG_COMPANY_ID  0x3E /* 0x41 for Analog Devices,
+                                        0xA1 for Philips */
+#define ADM1025_REG_DIE_REV     0x3F /* 0x20-0x2F for ADM1025 and compatible */
+
+#define ADM1025_REG_STATUS1     0x41
+#define ADM1025_REG_STATUS2     0x42
+
+#define ADM1025_REG_VID         0x47
+#define ADM1025_REG_VID4        0x49 /* actually R/W
+                                        but we don't write to it */
+
+/* These are read/write */
+#define ADM1025_REG_2_5V_HIGH   0x2B /* not used directly, see       */
+#define ADM1025_REG_2_5V_LOW    0x2C /* ADM1025_REG_IN_MAX(nr) and   */
+#define ADM1025_REG_VCCP1_HIGH  0x2D /* ADM1025_REG_IN_MIN(nr) below */
+#define ADM1025_REG_VCCP1_LOW   0x2E
+#define ADM1025_REG_3_3V_HIGH   0x2F
+#define ADM1025_REG_3_3V_LOW    0x30
+#define ADM1025_REG_5V_HIGH     0x31
+#define ADM1025_REG_5V_LOW      0x32
+#define ADM1025_REG_12V_HIGH    0x33
+#define ADM1025_REG_12V_LOW     0x34
+#define ADM1025_REG_VCC_HIGH    0x35
+#define ADM1025_REG_VCC_LOW     0x36
+
+#define ADM1025_REG_RTEMP_HIGH  0x37 /* not used directly, see         */
+#define ADM1025_REG_RTEMP_LOW   0x38 /* ADM1025_REG_TEMP_MAX(nr) and   */
+#define ADM1025_REG_LTEMP_HIGH  0x39 /* ADM1025_REG_TEMP_MIN(nr) below */
+#define ADM1025_REG_LTEMP_LOW   0x3A
+
+#define ADM1025_REG_CONFIG      0x40
+
+/* Useful macros */
+#define ADM1025_REG_IN(nr)        (ADM1025_REG_2_5V + (nr))
+#define ADM1025_REG_IN_MAX(nr)    (ADM1025_REG_2_5V_HIGH + (nr) * 2)
+#define ADM1025_REG_IN_MIN(nr)    (ADM1025_REG_2_5V_LOW + (nr) * 2)
+#define ADM1025_REG_TEMP(nr)      (ADM1025_REG_RTEMP + (nr))
+#define ADM1025_REG_TEMP_HIGH(nr) (ADM1025_REG_RTEMP_HIGH + (nr) * 2)
+#define ADM1025_REG_TEMP_LOW(nr)  (ADM1025_REG_RTEMP_LOW + (nr) * 2)
+
+/* Conversions. Rounding and limit checking is only done on the TO_REG
+   variants. Note that you should be a bit careful with which arguments
+   these macros are called: arguments may be evaluated more than once.
+   Fixing this is just not worth it. */
+#define IN_TO_REG(val) SENSORS_LIMIT(val, 0, 255)
+#define IN_FROM_REG(val) (val)
+
+#define TEMP_FROM_REG(val) (((val)>=0x80?(val)-0x100:(val))*10)
+#define TEMP_TO_REG(val) SENSORS_LIMIT(((val)<0?(((val)-5)/10):\
+                                                 ((val)+5)/10),-128,127)
+
+#define ALARMS_FROM_REG(val) (val)
+
+/* For each registered ADM1025, we need to keep some data in memory. That
+   data is pointed to by adm1025_list[NR]->data. The structure itself is
+   dynamically allocated, at the same time when a new adm1025 client is
+   allocated. */
+struct adm1025_data {
+       struct i2c_client client;
+       int sysctl_id;
+       enum chips type;
+
+       struct semaphore update_lock;
+       char valid;                   /* !=0 if following fields are valid */
+       unsigned long last_updated;   /* In jiffies */
+
+       u8 in[6];               /* Register value */
+       u8 in_max[6];           /* Register value */
+       u8 in_min[6];           /* Register value */
+       u8 temp[2];             /* Register value */
+       u8 temp_high[2];        /* Register value */
+       u8 temp_low[2];         /* Register value */
+       u16 alarms;             /* Register encoding, combined */
+       u8 vid;                 /* Register value combined */
+       u8 vrm;
+};
+
+
+static int adm1025_attach_adapter(struct i2c_adapter *adapter);
+static int adm1025_detect(struct i2c_adapter *adapter, int address,
+                         unsigned short flags, int kind);
+static int adm1025_detach_client(struct i2c_client *client);
+static void adm1025_update_client(struct i2c_client *client);
+static void adm1025_init_client(struct i2c_client *client);
+
+
+static void adm1025_in(struct i2c_client *client, int operation,
+                      int ctl_name, int *nrels_mag, long *results);
+static void adm1025_temp(struct i2c_client *client, int operation,
+                        int ctl_name, int *nrels_mag, long *results);
+static void adm1025_alarms(struct i2c_client *client, int operation,
+                          int ctl_name, int *nrels_mag, long *results);
+static void adm1025_vid(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void adm1025_vrm(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+
+static int adm1025_id = 0;
+
+static struct i2c_driver adm1025_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "ADM1025 sensor driver",
+       .id             = I2C_DRIVERID_ADM1025,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = adm1025_attach_adapter,
+       .detach_client  = adm1025_detach_client,
+};
+
+/* The /proc/sys entries */
+/* -- SENSORS SYSCTL START -- */
+
+#define ADM1025_SYSCTL_IN0     1000 /* Volts * 100 */
+#define ADM1025_SYSCTL_IN1     1001
+#define ADM1025_SYSCTL_IN2     1002
+#define ADM1025_SYSCTL_IN3     1003
+#define ADM1025_SYSCTL_IN4     1004
+#define ADM1025_SYSCTL_IN5     1005
+
+#define ADM1025_SYSCTL_RTEMP   1250 /* Degrees Celcius * 10 */
+#define ADM1025_SYSCTL_TEMP    1251
+
+#define ADM1025_SYSCTL_ALARMS  2001 /* bitvector */
+#define ADM1025_SYSCTL_VID     2003 /* Volts * 1000 */
+#define ADM1025_SYSCTL_VRM     2004
+
+#define ADM1025_ALARM_IN0     0x0001
+#define ADM1025_ALARM_IN1     0x0002
+#define ADM1025_ALARM_IN2     0x0004
+#define ADM1025_ALARM_IN3     0x0008
+#define ADM1025_ALARM_IN4     0x0100
+#define ADM1025_ALARM_IN5     0x0200
+#define ADM1025_ALARM_RTEMP   0x0020
+#define ADM1025_ALARM_TEMP    0x0010
+#define ADM1025_ALARM_RFAULT  0x4000
+
+/* -- SENSORS SYSCTL END -- */
+
+/* These files are created for each detected ADM1025. This is just a template;
+   though at first sight, you might think we could use a statically
+   allocated list, we need some way to get back to the parent - which
+   is done through one of the 'extra' fields which are initialized 
+   when a new copy is allocated. */
+static ctl_table adm1025_dir_table_template[] = {
+       {ADM1025_SYSCTL_IN0, "in0", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm1025_in},
+       {ADM1025_SYSCTL_IN1, "in1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm1025_in},
+       {ADM1025_SYSCTL_IN2, "in2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm1025_in},
+       {ADM1025_SYSCTL_IN3, "in3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm1025_in},
+       {ADM1025_SYSCTL_IN4, "in4", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm1025_in},
+       {ADM1025_SYSCTL_IN5, "in5", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm1025_in},
+       {ADM1025_SYSCTL_RTEMP, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm1025_temp},
+       {ADM1025_SYSCTL_TEMP, "temp2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm1025_temp},
+       {ADM1025_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm1025_alarms},
+       {ADM1025_SYSCTL_VID, "vid", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm1025_vid},
+       {ADM1025_SYSCTL_VRM, "vrm", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm1025_vrm},
+       {0}
+};
+
+static int adm1025_attach_adapter(struct i2c_adapter *adapter)
+{
+       return i2c_detect(adapter, &addr_data, adm1025_detect);
+}
+
+static int adm1025_detect(struct i2c_adapter *adapter, int address,
+                         unsigned short flags, int kind)
+{
+       int i;
+       struct i2c_client *new_client;
+       struct adm1025_data *data;
+       int err = 0;
+       const char *type_name = "";
+       const char *client_name = "";
+
+       /* Make sure we aren't probing the ISA bus!! This is just a safety check
+          at this moment; i2c_detect really won't call us. */
+#ifdef DEBUG
+       if (i2c_is_isa_adapter(adapter)) {
+               printk
+                   ("adm1025.o: adm1025_detect called for an ISA bus adapter?!?\n");
+               return 0;
+       }
+#endif
+
+       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
+               goto ERROR0;
+
+       /* OK. For now, we presume we have a valid client. We now create the
+          client structure, even though we cannot fill it completely yet.
+          But it allows us to access adm1025_{read,write}_value. */
+
+       if (!(data = kmalloc(sizeof(struct adm1025_data), GFP_KERNEL))) {
+               err = -ENOMEM;
+               goto ERROR0;
+       }
+
+       new_client = &data->client;
+       new_client->addr = address;
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &adm1025_driver;
+       new_client->flags = 0;
+
+       /* Now, we do the remaining detection. */
+
+       if (kind < 0) {
+               if ((i2c_smbus_read_byte_data(new_client,
+                    ADM1025_REG_CONFIG) & 0x80) != 0x00
+                || (i2c_smbus_read_byte_data(new_client,
+                    ADM1025_REG_STATUS1) & 0xC0) != 0x00
+                || (i2c_smbus_read_byte_data(new_client,
+                    ADM1025_REG_STATUS2) & 0xBC) != 0x00)
+                       goto ERROR1;
+       }
+
+       /* Determine the chip type. */
+       if (kind <= 0) {
+               u8 man_id, chip_id;
+               
+               man_id = i2c_smbus_read_byte_data(new_client,
+                        ADM1025_REG_COMPANY_ID);
+               chip_id = i2c_smbus_read_byte_data(new_client,
+                         ADM1025_REG_DIE_REV);
+               
+               if (man_id == 0x41) { /* Analog Devices */
+                       if ((chip_id & 0xF0) == 0x20) /* ADM1025 */
+                               kind = adm1025;
+               } else if (man_id == 0xA1) { /* Philips */
+                       if (address != 0x2E
+                        && (chip_id & 0xF0) == 0x20) /* NE1619 */
+                               kind = ne1619;
+               }
+       }
+
+       if (kind <= 0) { /* Identification failed */
+               printk("adm1025.o: Unsupported chip.\n");
+               goto ERROR1;
+       }
+
+       if (kind == adm1025) {
+               type_name = "adm1025";
+               client_name = "ADM1025 chip";
+       } else if (kind == ne1619) {
+               type_name = "ne1619";
+               client_name = "NE1619 chip";            
+       } else {
+#ifdef DEBUG
+               printk("adm1025.o: Internal error: unknown kind (%d)?!?",
+                      kind);
+#endif
+               goto ERROR1;
+       }
+
+       /* Fill in the remaining client fields and put it into the global list */
+       strcpy(new_client->name, client_name);
+       data->type = kind;
+
+       new_client->id = adm1025_id++;
+       data->valid = 0;
+       init_MUTEX(&data->update_lock);
+
+       /* Tell the I2C layer a new client has arrived */
+       if ((err = i2c_attach_client(new_client)))
+               goto ERROR3;
+
+       /* Register a new directory entry with module sensors */
+       if ((i = i2c_register_entry(new_client,
+                                       type_name,
+                                       adm1025_dir_table_template)) < 0) {
+               err = i;
+               goto ERROR4;
+       }
+       data->sysctl_id = i;
+
+       /* Initialize the ADM1025 chip */
+       adm1025_init_client(new_client);
+       return 0;
+
+/* OK, this is not exactly good programming practice, usually. But it is
+   very code-efficient in this case. */
+
+      ERROR4:
+       i2c_detach_client(new_client);
+      ERROR3:
+      ERROR1:
+       kfree(data);
+      ERROR0:
+       return err;
+}
+
+static int adm1025_detach_client(struct i2c_client *client)
+{
+       int err;
+
+       i2c_deregister_entry(((struct adm1025_data *) (client->data))->
+                                sysctl_id);
+
+       if ((err = i2c_detach_client(client))) {
+               printk
+                   ("adm1025.o: Client deregistration failed, client not detached.\n");
+               return err;
+       }
+
+       kfree(client->data);
+
+       return 0;
+}
+
+/* Called when we have found a new ADM1025. */
+static void adm1025_init_client(struct i2c_client *client)
+{
+       struct adm1025_data *data = client->data;
+       u8 reg;
+       int i;
+
+       data->vrm = 82;
+
+       /* Set high limits
+          Usually we avoid setting limits on driver init, but it happens
+          that the ADM1025 comes with stupid default limits (all registers
+          set to 0). In case the chip has not gone through any limit
+          setting yet, we better set the high limits to the max so that
+          no alarm triggers. */
+       for (i=0; i<6; i++) {
+               reg = i2c_smbus_read_byte_data(client,
+                                              ADM1025_REG_IN_MAX(i));
+               if (reg == 0)
+                       i2c_smbus_write_byte_data(client,
+                                                 ADM1025_REG_IN_MAX(i),
+                                                 0xFF);
+       }
+       for (i=0; i<2; i++) {
+               reg = i2c_smbus_read_byte_data(client,
+                                              ADM1025_REG_TEMP_HIGH(i));
+               if (reg == 0)
+                       i2c_smbus_write_byte_data(client,
+                                                 ADM1025_REG_TEMP_HIGH(i),
+                                                 0x7F);
+       }
+
+       /* Start monitoring */
+       reg = i2c_smbus_read_byte_data(client, ADM1025_REG_CONFIG);
+       i2c_smbus_write_byte_data(client, ADM1025_REG_CONFIG, (reg|0x01)&0x7F);
+}
+
+static void adm1025_update_client(struct i2c_client *client)
+{
+       struct adm1025_data *data = client->data;
+       u8 nr;
+
+       down(&data->update_lock);
+
+       if ((jiffies - data->last_updated > 2 * HZ)
+        || (jiffies < data->last_updated) || !data->valid) {
+#ifdef DEBUG
+               printk("Starting adm1025 update\n");
+#endif
+
+               /* Voltages */
+               for (nr = 0; nr < 6; nr++) {
+                       data->in[nr] = i2c_smbus_read_byte_data(client, ADM1025_REG_IN(nr));
+                       data->in_min[nr] = i2c_smbus_read_byte_data(client, ADM1025_REG_IN_MIN(nr));
+                       data->in_max[nr] = i2c_smbus_read_byte_data(client, ADM1025_REG_IN_MAX(nr));
+               }
+
+               /* Temperatures */
+               for (nr = 0; nr < 2; nr++) {
+                       data->temp[nr] = i2c_smbus_read_byte_data(client, ADM1025_REG_TEMP(nr));
+                       data->temp_high[nr] = i2c_smbus_read_byte_data(client, ADM1025_REG_TEMP_HIGH(nr));
+                       data->temp_low[nr] = i2c_smbus_read_byte_data(client, ADM1025_REG_TEMP_LOW(nr));
+               }
+
+               /* VID */
+               data->vid = (i2c_smbus_read_byte_data(client, ADM1025_REG_VID) & 0x0f)
+                        + ((i2c_smbus_read_byte_data(client, ADM1025_REG_VID4) & 0x01) << 4);
+
+               /* Alarms */
+               data->alarms = (i2c_smbus_read_byte_data(client, ADM1025_REG_STATUS1) & 0x3f)
+                           + ((i2c_smbus_read_byte_data(client, ADM1025_REG_STATUS2) & 0x43) << 8);
+
+               data->last_updated = jiffies;
+               data->valid = 1;
+       }
+
+       up(&data->update_lock);
+}
+
+
+/* The next few functions are the call-back functions of the /proc/sys and
+   sysctl files. Which function is used is defined in the ctl_table in
+   the extra1 field.
+   Each function must return the magnitude (power of 10 to divide the data
+   with) if it is called with operation==SENSORS_PROC_REAL_INFO. It must
+   put a maximum of *nrels elements in results reflecting the data of this
+   file, and set *nrels to the number it actually put in it, if operation==
+   SENSORS_PROC_REAL_READ. Finally, it must get upto *nrels elements from
+   results and write them to the chip, if operations==SENSORS_PROC_REAL_WRITE.
+   Note that on SENSORS_PROC_REAL_READ, I do not check whether results is
+   large enough (by checking the incoming value of *nrels). This is not very
+   good practice, but as long as you put less than about 5 values in results,
+   you can assume it is large enough. */
+void adm1025_in(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       int scales[6] = { 250, 225, 330, 500, 1200, 330 };
+
+       struct adm1025_data *data = client->data;
+       int nr = ctl_name - ADM1025_SYSCTL_IN0;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 2;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm1025_update_client(client);
+               results[0] = (IN_FROM_REG(data->in_min[nr]) * scales[nr] + 96) / 192;
+               results[1] = (IN_FROM_REG(data->in_max[nr]) * scales[nr] + 96) / 192;
+               results[2] = (IN_FROM_REG(data->in[nr]) * scales[nr] + 96) / 192;
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->in_min[nr] = IN_TO_REG((results[0] * 192 + scales[nr] / 2)
+                                          / scales[nr]);
+                       i2c_smbus_write_byte_data(client, ADM1025_REG_IN_MIN(nr),
+                                           data->in_min[nr]);
+               }
+               if (*nrels_mag >= 2) {
+                       data->in_max[nr] = IN_TO_REG((results[1] * 192 + scales[nr] / 2)
+                                          / scales[nr]);
+                       i2c_smbus_write_byte_data(client, ADM1025_REG_IN_MAX(nr),
+                                           data->in_max[nr]);
+               }
+       }
+}
+
+void adm1025_temp(struct i2c_client *client, int operation, int ctl_name,
+                 int *nrels_mag, long *results)
+{
+       struct adm1025_data *data = client->data;
+       int nr = ctl_name - ADM1025_SYSCTL_RTEMP;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm1025_update_client(client);
+               results[0] = TEMP_FROM_REG(data->temp_high[nr]);
+               results[1] = TEMP_FROM_REG(data->temp_low[nr]);
+               results[2] = TEMP_FROM_REG(data->temp[nr]);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->temp_high[nr] = TEMP_TO_REG(results[0]);
+                       i2c_smbus_write_byte_data(client, ADM1025_REG_TEMP_HIGH(nr),
+                                           data->temp_high[nr]);
+               }
+               if (*nrels_mag >= 2) {
+                       data->temp_low[nr] = TEMP_TO_REG(results[1]);
+                       i2c_smbus_write_byte_data(client, ADM1025_REG_TEMP_LOW(nr),
+                                           data->temp_low[nr]);
+               }
+       }
+}
+
+void adm1025_alarms(struct i2c_client *client, int operation, int ctl_name,
+                   int *nrels_mag, long *results)
+{
+       struct adm1025_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm1025_update_client(client);
+               results[0] = ALARMS_FROM_REG(data->alarms);
+               *nrels_mag = 1;
+       }
+}
+
+void adm1025_vid(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct adm1025_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 3;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm1025_update_client(client);
+               results[0] = vid_from_reg(data->vid, data->vrm);
+               *nrels_mag = 1;
+       }
+}
+
+void adm1025_vrm(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct adm1025_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               results[0] = data->vrm;
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1)
+                       data->vrm = results[0];
+       }
+}
+
+static int __init sm_adm1025_init(void)
+{
+       printk("adm1025.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       return i2c_add_driver(&adm1025_driver);
+}
+
+static void __exit sm_adm1025_exit(void)
+{
+       i2c_del_driver(&adm1025_driver);
+}
+
+
+
+MODULE_AUTHOR("Chen-Yuan Wu <gwu@esoft.com>"
+       " and Jean Delvare <khali@linux-fr.org>");
+MODULE_DESCRIPTION("ADM1025 driver");
+
+module_init(sm_adm1025_init);
+module_exit(sm_adm1025_exit);
--- linux-old/drivers/sensors/adm1026.c Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/adm1026.c     Mon Dec 13 20:18:44 2004
@@ -0,0 +1,1745 @@
+/*
+    adm1026.c - Part of lm_sensors, Linux kernel modules for hardware
+             monitoring
+    Copyright (c) 2002, 2003  Philip Pokorny <ppokorny@penguincomputing.com>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+    CHANGELOG
+
+    2003-03-13   Initial development
+    2003-05-07   First Release.  Includes GPIO fixup and full
+                 functionality.
+    2003-05-18   Minor fixups and tweaks.
+                 Print GPIO config after fixup.
+                 Adjust fan MIN if DIV changes.
+    2003-05-21   Fix printing of FAN/GPIO config
+                 Fix silly bug in fan_div logic
+                 Fix fan_min handling so that 0xff is 0 is 0xff
+    2003-05-25   Fix more silly typos...
+    2003-06-11   Change FAN_xx_REG macros to use different scaling
+                 Most (all?) drivers assume two pulses per rev fans
+                 and the old scaling was producing double the RPM's
+                 Thanks to Jerome Hsiao @ Arima for pointing this out.
+       2004-01-27   Remove use of temporary ID.
+                 Define addresses as a range.
+*/
+
+#include <linux/version.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+#include <linux/sensors_vid.h>
+
+#ifndef I2C_DRIVERID_ADM1026
+#define I2C_DRIVERID_ADM1026   1048
+#endif
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = { SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { 0x2c, 0x2e, SENSORS_I2C_END };
+static unsigned int normal_isa[] = { SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+/* Insmod parameters */
+SENSORS_INSMOD_1(adm1026);
+
+static int gpio_input[17]  = { -1, -1, -1, -1, -1, -1, -1, -1, -1,
+                               -1, -1, -1, -1, -1, -1, -1, -1 };
+static int gpio_output[17] = { -1, -1, -1, -1, -1, -1, -1, -1, -1,
+                               -1, -1, -1, -1, -1, -1, -1, -1 };
+static int gpio_inverted[17] = { -1, -1, -1, -1, -1, -1, -1, -1, -1,
+                               -1, -1, -1, -1, -1, -1, -1, -1 };
+static int gpio_normal[17] = { -1, -1, -1, -1, -1, -1, -1, -1, -1,
+                               -1, -1, -1, -1, -1, -1, -1, -1 };
+static int gpio_fan[8] = { -1, -1, -1, -1, -1, -1, -1, -1 };
+MODULE_PARM(gpio_input,"1-17i");
+MODULE_PARM_DESC(gpio_input,"List of GPIO pins (0-16) to program as inputs");
+MODULE_PARM(gpio_output,"1-17i");
+MODULE_PARM_DESC(gpio_output,"List of GPIO pins (0-16) to program as outputs");
+MODULE_PARM(gpio_inverted,"1-17i");
+MODULE_PARM_DESC(gpio_inverted,"List of GPIO pins (0-16) to program as inverted");
+MODULE_PARM(gpio_normal,"1-17i");
+MODULE_PARM_DESC(gpio_normal,"List of GPIO pins (0-16) to program as normal/non-inverted");
+MODULE_PARM(gpio_fan,"1-8i");
+MODULE_PARM_DESC(gpio_fan,"List of GPIO pins (0-7) to program as fan tachs");
+
+/* Many ADM1026 constants specified below */
+
+/* The ADM1026 registers */
+#define ADM1026_REG_CONFIG1  (0x00)
+#define CFG1_MONITOR     (0x01)
+#define CFG1_INT_ENABLE  (0x02)
+#define CFG1_INT_CLEAR   (0x04)
+#define CFG1_AIN8_9      (0x08)
+#define CFG1_THERM_HOT   (0x10)
+#define CFG1_DAC_AFC     (0x20)
+#define CFG1_PWM_AFC     (0x40)
+#define CFG1_RESET       (0x80)
+#define ADM1026_REG_CONFIG2  (0x01)
+/* CONFIG2 controls FAN0/GPIO0 through FAN7/GPIO7 */
+#define ADM1026_REG_CONFIG3  (0x07)
+#define CFG3_GPIO16_ENABLE  (0x01)
+#define CFG3_CI_CLEAR  (0x02)
+#define CFG3_VREF_250  (0x04)
+#define CFG3_GPIO16_DIR  (0x40)
+#define CFG3_GPIO16_POL  (0x80)
+#define ADM1026_REG_E2CONFIG  (0x13)
+#define E2CFG_READ  (0x01)
+#define E2CFG_WRITE  (0x02)
+#define E2CFG_ERASE  (0x04)
+#define E2CFG_ROM  (0x08)
+#define E2CFG_CLK_EXT  (0x80)
+
+/* There are 10 general analog inputs and 7 dedicated inputs
+ * They are:
+ *    0 - 9  =  AIN0 - AIN9
+ *       10  =  Vbat
+ *       11  =  3.3V Standby
+ *       12  =  3.3V Main
+ *       13  =  +5V
+ *       14  =  Vccp (CPU core voltage)
+ *       15  =  +12V
+ *       16  =  -12V
+ */
+static u16 REG_IN[] = {
+               0x30, 0x31, 0x32, 0x33, 0x34, 0x35,
+               0x36, 0x37, 0x27, 0x29, 0x26, 0x2a,
+               0x2b, 0x2c, 0x2d, 0x2e, 0x2f
+       };
+static u16 REG_IN_MIN[] = {
+               0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d,
+               0x5e, 0x5f, 0x6d, 0x49, 0x6b, 0x4a,
+               0x4b, 0x4c, 0x4d, 0x4e, 0x4f
+       };
+static u16 REG_IN_MAX[] = {
+               0x50, 0x51, 0x52, 0x53, 0x54, 0x55,
+               0x56, 0x57, 0x6c, 0x41, 0x6a, 0x42,
+               0x43, 0x44, 0x45, 0x46, 0x47
+       };
+#define ADM1026_REG_IN(nr) (REG_IN[(nr)])
+#define ADM1026_REG_IN_MIN(nr) (REG_IN_MIN[(nr)])
+#define ADM1026_REG_IN_MAX(nr) (REG_IN_MAX[(nr)])
+
+/* Temperatures are:
+ *    0 - Internal
+ *    1 - External 1
+ *    2 - External 2
+ */
+static u16 REG_TEMP[] = { 0x1f, 0x28, 0x29 };
+static u16 REG_TEMP_MIN[] = { 0x69, 0x48, 0x49 };
+static u16 REG_TEMP_MAX[] = { 0x68, 0x40, 0x41 };
+static u16 REG_TEMP_TMIN[] = { 0x10, 0x11, 0x12 };
+static u16 REG_TEMP_THERM[] = { 0x0d, 0x0e, 0x0f };
+static u16 REG_TEMP_OFFSET[] = { 0x1e, 0x6e, 0x6f };
+#define ADM1026_REG_TEMP(nr) (REG_TEMP[(nr)])
+#define ADM1026_REG_TEMP_MIN(nr) (REG_TEMP_MIN[(nr)])
+#define ADM1026_REG_TEMP_MAX(nr) (REG_TEMP_MAX[(nr)])
+#define ADM1026_REG_TEMP_TMIN(nr) (REG_TEMP_TMIN[(nr)])
+#define ADM1026_REG_TEMP_THERM(nr) (REG_TEMP_THERM[(nr)])
+#define ADM1026_REG_TEMP_OFFSET(nr) (REG_TEMP_OFFSET[(nr)])
+
+#define ADM1026_REG_FAN(nr) (0x38 + (nr))
+#define ADM1026_REG_FAN_MIN(nr) (0x60 + (nr))
+#define ADM1026_REG_FAN_DIV_0_3 (0x02)
+#define ADM1026_REG_FAN_DIV_4_7 (0x03)
+
+#define ADM1026_REG_DAC  (0x04)
+#define ADM1026_REG_PWM  (0x05)
+
+#define ADM1026_REG_GPIO_CFG_0_3 (0x08)
+#define ADM1026_REG_GPIO_CFG_4_7 (0x09)
+#define ADM1026_REG_GPIO_CFG_8_11 (0x0a)
+#define ADM1026_REG_GPIO_CFG_12_15 (0x0b)
+/* CFG_16 in REG_CFG3 */
+#define ADM1026_REG_GPIO_STATUS_0_7 (0x24)
+#define ADM1026_REG_GPIO_STATUS_8_15 (0x25)
+/* STATUS_16 in REG_STATUS4 */
+#define ADM1026_REG_GPIO_MASK_0_7 (0x1c)
+#define ADM1026_REG_GPIO_MASK_8_15 (0x1d)
+/* MASK_16 in REG_MASK4 */
+
+#define ADM1026_REG_COMPANY 0x16
+#define ADM1026_REG_VERSTEP 0x17
+/* These are the recognized values for the above regs */
+#define ADM1026_COMPANY_ANALOG_DEV 0x41
+#define ADM1026_VERSTEP_GENERIC 0x40
+#define ADM1026_VERSTEP_ADM1026 0x44
+
+#define ADM1026_REG_MASK1 0x18
+#define ADM1026_REG_MASK2 0x19
+#define ADM1026_REG_MASK3 0x1a
+#define ADM1026_REG_MASK4 0x1b
+
+#define ADM1026_REG_STATUS1 0x20
+#define ADM1026_REG_STATUS2 0x21
+#define ADM1026_REG_STATUS3 0x22
+#define ADM1026_REG_STATUS4 0x23
+
+/* Conversions. Rounding and limit checking is only done on the TO_REG 
+   variants. Note that you should be a bit careful with which arguments
+   these macros are called: arguments may be evaluated more than once.
+ */
+
+/* IN are scaled acording to built-in resistors.  These are the
+ *   voltages corresponding to 3/4 of full scale (192 or 0xc0)
+ *   NOTE: The -12V input needs an additional factor to account
+ *      for the Vref pullup resistor.
+ *      NEG12_OFFSET = SCALE * Vref / V-192 - Vref
+ *                   = 13875 * 2.50 / 1.875 - 2500
+ *                   = 16000
+ */
+#if 1
+/* The values in this table are based on Table II, page 15 of the
+ *    datasheet.
+ */
+static int adm1026_scaling[] = {  /* .001 Volts */
+               2250, 2250, 2250, 2250, 2250, 2250, 
+               1875, 1875, 1875, 1875, 3000, 3330, 
+               3330, 4995, 2250, 12000, 13875
+       };
+#define NEG12_OFFSET  16000
+#else
+/* The values in this table are based on the resistors in 
+ *    Figure 5 on page 16.  But the 3.3V inputs are not in
+ *    the figure and the values for the 5V input are wrong.
+ *    For 5V, I'm guessing that R2 at 55.2k is right, but
+ *    the total resistance should be 1400 or 1449 like the
+ *    other inputs.  Using 1449, gives 4.922V at 192.
+ */
+static int adm1026_scaling[] = {  /* .001 Volts */
+               2249, 2249, 2249, 2249, 2249, 2249, 
+               1875, 1875, 1875, 1875, 3329, 3329, 
+               3329, 4922, 2249, 11969, 13889
+       };
+#define NEG12_OFFSET  16019
+#endif
+
+#define SCALE(val,from,to) (((val)*(to) + ((from)/2))/(from))
+#define INS_TO_REG(n,val)  (SENSORS_LIMIT(SCALE(val,adm1026_scaling[n],192),0,255))
+#if 0   /* If we have extended A/D bits */
+#define INSEXT_FROM_REG(n,val,ext) (SCALE((val)*4 + (ext),192*4,adm1026_scaling[n]))
+#define INS_FROM_REG(n,val) (INSEXT_FROM_REG(n,val,0))
+#else
+#define INS_FROM_REG(n,val) (SCALE(val,192,adm1026_scaling[n]))
+#endif
+
+/* FAN speed is measured using 22.5kHz clock and counts for 2 pulses
+ *   and we assume a 2 pulse-per-rev fan tach signal
+ *      22500 kHz * 60 (sec/min) * 2 (pulse) / 2 (pulse/rev) == 1350000
+ */
+#define FAN_TO_REG(val,div)  ((val)<=0 ? 0xff : SENSORS_LIMIT(1350000/((val)*(div)),1,254))
+#define FAN_FROM_REG(val,div) ((val)==0?-1:(val)==0xff ? 0 : 1350000/((val)*(div)))
+#define DIV_FROM_REG(val) (1<<(val))
+#define DIV_TO_REG(val) ((val)>=8 ? 3 : (val)>=4 ? 2 : (val)>=2 ? 1 : 0)
+
+/* Temperature is reported in 1 degC increments */
+#define TEMP_TO_REG(val) (SENSORS_LIMIT(val,-127,127))
+#define TEMP_FROM_REG(val) (val)
+#define OFFSET_TO_REG(val) (SENSORS_LIMIT(val,-127,127))
+#define OFFSET_FROM_REG(val) (val)
+
+#define PWM_TO_REG(val) (SENSORS_LIMIT(val,0,255))
+#define PWM_FROM_REG(val) (val)
+
+/* Analog output is a voltage, but it's used like a PWM
+ *   Seems like this should be scaled, but to be consistent
+ *   with other drivers, we do it this way.
+ */
+#define DAC_TO_REG(val) (SENSORS_LIMIT(val,0,255))
+#define DAC_FROM_REG(val) (val)
+
+/* sensors_vid.h defines vid_from_reg() */
+#define VID_FROM_REG(val,vrm) (vid_from_reg(val,vrm))
+
+#define ALARMS_FROM_REG(val) (val)
+
+/* Unlike some other drivers we DO NOT set initial limits.  Use
+ * the config file to set limits.
+ */
+
+/* Typically used with systems using a v9.1 VRM spec ? */
+#define ADM1026_INIT_VRM  91
+#define ADM1026_INIT_VID  -1
+
+/* Chip sampling rates
+ *
+ * Some sensors are not updated more frequently than once per second
+ *    so it doesn't make sense to read them more often than that.
+ *    We cache the results and return the saved data if the driver
+ *    is called again before a second has elapsed.
+ *
+ * Also, there is significant configuration data for this chip
+ *    So, we keep the config data up to date in the cache
+ *    when it is written and only sample it once every 5 *minutes*
+ */
+#define ADM1026_DATA_INTERVAL  (1 * HZ)
+#define ADM1026_CONFIG_INTERVAL  (5 * 60 * HZ)
+
+/* We allow for multiple chips in a single system.
+ *
+ * For each registered ADM1026, we need to keep state information
+ * at client->data. The adm1026_data structure is dynamically
+ * allocated, when a new client structure is allocated. */
+
+struct adm1026_data {
+       struct i2c_client client;
+       struct semaphore lock;
+       int sysctl_id;
+       enum chips type;
+
+       struct semaphore update_lock;
+       int valid;              /* !=0 if following fields are valid */
+       unsigned long last_reading;     /* In jiffies */
+       unsigned long last_config;      /* In jiffies */
+
+       u8 in[17];              /* Register value */
+       u8 in_max[17];          /* Register value */
+       u8 in_min[17];          /* Register value */
+       s8 temp[3];             /* Register value */
+       s8 temp_min[3];         /* Register value */
+       s8 temp_max[3];         /* Register value */
+       s8 temp_tmin[3];        /* Register value */
+       s8 temp_therm[3];       /* Register value */
+       s8 temp_offset[3];      /* Register value */
+       u8 fan[8];              /* Register value */
+       u8 fan_min[8];          /* Register value */
+       u8 fan_div[8];          /* Decoded value */
+       u8 pwm;                 /* Register value */
+       u8 analog_out;          /* Register value */
+       int vid;                /* Decoded value */
+       u8 vrm;                 /* VRM version */
+       long alarms;            /* Register encoding, combined */
+       long alarm_mask;        /* Register encoding, combined */
+       long gpio;              /* Register encoding, combined */
+       long gpio_mask;         /* Register encoding, combined */
+       u8 gpio_config[17];     /* Decoded value */
+       u8 config1;             /* Register value */
+       u8 config2;             /* Register value */
+       u8 config3;             /* Register value */
+};
+
+static int adm1026_attach_adapter(struct i2c_adapter *adapter);
+static int adm1026_detect(struct i2c_adapter *adapter, int address,
+                       unsigned short flags, int kind);
+static int adm1026_detach_client(struct i2c_client *client);
+
+static int adm1026_read_value(struct i2c_client *client, u8 register);
+static int adm1026_write_value(struct i2c_client *client, u8 register, int value);
+static void adm1026_print_gpio(struct i2c_client *client);
+static void adm1026_fixup_gpio(struct i2c_client *client);
+static void adm1026_update_client(struct i2c_client *client);
+static void adm1026_init_client(struct i2c_client *client);
+
+
+static void adm1026_in(struct i2c_client *client, int operation, int ctl_name,
+                       int *nrels_mag, long *results);
+static void adm1026_in16(struct i2c_client *client, int operation, int ctl_name,
+                       int *nrels_mag, long *results);
+static void adm1026_fan(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void adm1026_fixup_fan_min(struct i2c_client *client,
+                        int fan, int old_div);
+static void adm1026_fan_div(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void adm1026_temp(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void adm1026_temp_offset(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void adm1026_temp_tmin(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void adm1026_temp_therm(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void adm1026_vid(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void adm1026_vrm(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void adm1026_alarms(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void adm1026_alarm_mask(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void adm1026_gpio(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void adm1026_gpio_mask(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void adm1026_pwm(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void adm1026_analog_out(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void adm1026_afc(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+
+static struct i2c_driver adm1026_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "ADM1026 compatible sensor driver",
+       .id             = I2C_DRIVERID_ADM1026,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = &adm1026_attach_adapter,
+       .detach_client  = &adm1026_detach_client,
+};
+
+/* Unique ID assigned to each ADM1026 detected */
+static int adm1026_id = 0;
+
+/* -- SENSORS SYSCTL START -- */
+#define ADM1026_SYSCTL_FAN0                 1000
+#define ADM1026_SYSCTL_FAN1                 1001
+#define ADM1026_SYSCTL_FAN2                 1002
+#define ADM1026_SYSCTL_FAN3                 1003
+#define ADM1026_SYSCTL_FAN4                 1004
+#define ADM1026_SYSCTL_FAN5                 1005
+#define ADM1026_SYSCTL_FAN6                 1006
+#define ADM1026_SYSCTL_FAN7                 1007
+#define ADM1026_SYSCTL_FAN_DIV              1008
+#define ADM1026_SYSCTL_GPIO                 1009
+#define ADM1026_SYSCTL_GPIO_MASK            1010
+#define ADM1026_SYSCTL_ALARMS               1011
+#define ADM1026_SYSCTL_ALARM_MASK           1012
+#define ADM1026_SYSCTL_IN0                  1013
+#define ADM1026_SYSCTL_IN1                  1014
+#define ADM1026_SYSCTL_IN2                  1015
+#define ADM1026_SYSCTL_IN3                  1016
+#define ADM1026_SYSCTL_IN4                  1017
+#define ADM1026_SYSCTL_IN5                  1018
+#define ADM1026_SYSCTL_IN6                  1019
+#define ADM1026_SYSCTL_IN7                  1020
+#define ADM1026_SYSCTL_IN8                  1021
+#define ADM1026_SYSCTL_IN9                  1022
+#define ADM1026_SYSCTL_IN10                 1023
+#define ADM1026_SYSCTL_IN11                 1024
+#define ADM1026_SYSCTL_IN12                 1025
+#define ADM1026_SYSCTL_IN13                 1026
+#define ADM1026_SYSCTL_IN14                 1027
+#define ADM1026_SYSCTL_IN15                 1028
+#define ADM1026_SYSCTL_IN16                 1029
+#define ADM1026_SYSCTL_PWM                  1030
+#define ADM1026_SYSCTL_ANALOG_OUT           1031
+#define ADM1026_SYSCTL_AFC                  1032
+#define ADM1026_SYSCTL_TEMP1                1033
+#define ADM1026_SYSCTL_TEMP2                1034
+#define ADM1026_SYSCTL_TEMP3                1035
+#define ADM1026_SYSCTL_TEMP_OFFSET1         1036
+#define ADM1026_SYSCTL_TEMP_OFFSET2         1037
+#define ADM1026_SYSCTL_TEMP_OFFSET3         1038
+#define ADM1026_SYSCTL_TEMP_THERM1          1039
+#define ADM1026_SYSCTL_TEMP_THERM2          1040
+#define ADM1026_SYSCTL_TEMP_THERM3          1041
+#define ADM1026_SYSCTL_TEMP_TMIN1           1042
+#define ADM1026_SYSCTL_TEMP_TMIN2           1043
+#define ADM1026_SYSCTL_TEMP_TMIN3           1044
+#define ADM1026_SYSCTL_VID                  1045
+#define ADM1026_SYSCTL_VRM                  1046
+
+#define ADM1026_ALARM_TEMP2   (1L <<  0)
+#define ADM1026_ALARM_TEMP3   (1L <<  1)
+#define ADM1026_ALARM_IN9     (1L <<  1)
+#define ADM1026_ALARM_IN11    (1L <<  2)
+#define ADM1026_ALARM_IN12    (1L <<  3)
+#define ADM1026_ALARM_IN13    (1L <<  4)
+#define ADM1026_ALARM_IN14    (1L <<  5)
+#define ADM1026_ALARM_IN15    (1L <<  6)
+#define ADM1026_ALARM_IN16    (1L <<  7)
+#define ADM1026_ALARM_IN0     (1L <<  8)
+#define ADM1026_ALARM_IN1     (1L <<  9)
+#define ADM1026_ALARM_IN2     (1L << 10)
+#define ADM1026_ALARM_IN3     (1L << 11)
+#define ADM1026_ALARM_IN4     (1L << 12)
+#define ADM1026_ALARM_IN5     (1L << 13)
+#define ADM1026_ALARM_IN6     (1L << 14)
+#define ADM1026_ALARM_IN7     (1L << 15)
+#define ADM1026_ALARM_FAN0    (1L << 16)
+#define ADM1026_ALARM_FAN1    (1L << 17)
+#define ADM1026_ALARM_FAN2    (1L << 18)
+#define ADM1026_ALARM_FAN3    (1L << 19)
+#define ADM1026_ALARM_FAN4    (1L << 20)
+#define ADM1026_ALARM_FAN5    (1L << 21)
+#define ADM1026_ALARM_FAN6    (1L << 22)
+#define ADM1026_ALARM_FAN7    (1L << 23)
+#define ADM1026_ALARM_TEMP1   (1L << 24)
+#define ADM1026_ALARM_IN10    (1L << 25)
+#define ADM1026_ALARM_IN8     (1L << 26)
+#define ADM1026_ALARM_THERM   (1L << 27)
+#define ADM1026_ALARM_AFC_FAN (1L << 28)
+#define ADM1026_ALARM_UNUSED  (1L << 29)
+#define ADM1026_ALARM_CI      (1L << 30)
+/* -- SENSORS SYSCTL END -- */
+
+/* The /proc/sys entries */
+/* These files are created for each detected ADM1026. This is just a template;
+ *    The actual list is built from this and additional per-chip
+ *    custom lists below.  Note the XXX_LEN macros.  These must be
+ *    compile time constants because they will be used to allocate
+ *    space for the final template passed to i2c_register_entry.
+ *    We depend on the ability of GCC to evaluate expressions at
+ *    compile time to turn these expressions into compile time
+ *    constants, but this can generate a warning.
+ */
+static ctl_table adm1026_common[] = {
+       {ADM1026_SYSCTL_IN0, "in0", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &adm1026_in},
+       {ADM1026_SYSCTL_IN1, "in1", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &adm1026_in},
+       {ADM1026_SYSCTL_IN2, "in2", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &adm1026_in},
+       {ADM1026_SYSCTL_IN3, "in3", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &adm1026_in},
+       {ADM1026_SYSCTL_IN4, "in4", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &adm1026_in},
+       {ADM1026_SYSCTL_IN5, "in5", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &adm1026_in},
+       {ADM1026_SYSCTL_IN6, "in6", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &adm1026_in},
+       {ADM1026_SYSCTL_IN7, "in7", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &adm1026_in},
+       {ADM1026_SYSCTL_IN8, "in8", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &adm1026_in},
+       {ADM1026_SYSCTL_IN9, "in9", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &adm1026_in},
+       {ADM1026_SYSCTL_IN10, "in10", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &adm1026_in},
+       {ADM1026_SYSCTL_IN11, "in11", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &adm1026_in},
+       {ADM1026_SYSCTL_IN12, "in12", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &adm1026_in},
+       {ADM1026_SYSCTL_IN13, "in13", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &adm1026_in},
+       {ADM1026_SYSCTL_IN14, "in14", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &adm1026_in},
+       {ADM1026_SYSCTL_IN15, "in15", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &adm1026_in},
+       {ADM1026_SYSCTL_IN16, "in16", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &adm1026_in16},
+
+       {ADM1026_SYSCTL_FAN0, "fan0", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &adm1026_fan},
+       {ADM1026_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &adm1026_fan},
+       {ADM1026_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &adm1026_fan},
+       {ADM1026_SYSCTL_FAN3, "fan3", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &adm1026_fan},
+       {ADM1026_SYSCTL_FAN4, "fan4", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &adm1026_fan},
+       {ADM1026_SYSCTL_FAN5, "fan5", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &adm1026_fan},
+       {ADM1026_SYSCTL_FAN6, "fan6", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &adm1026_fan},
+       {ADM1026_SYSCTL_FAN7, "fan7", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &adm1026_fan},
+       {ADM1026_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL,
+               &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_fan_div},
+
+       {ADM1026_SYSCTL_TEMP1, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &adm1026_temp},
+       {ADM1026_SYSCTL_TEMP2, "temp2", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &adm1026_temp},
+       {ADM1026_SYSCTL_TEMP3, "temp3", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &adm1026_temp},
+       {ADM1026_SYSCTL_TEMP_OFFSET1, "temp1_offset", NULL, 0, 0644, NULL,
+               &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_temp_offset},
+       {ADM1026_SYSCTL_TEMP_OFFSET2, "temp2_offset", NULL, 0, 0644, NULL,
+               &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_temp_offset},
+       {ADM1026_SYSCTL_TEMP_OFFSET3, "temp3_offset", NULL, 0, 0644, NULL,
+               &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_temp_offset},
+       {ADM1026_SYSCTL_TEMP_TMIN1, "temp1_tmin", NULL, 0, 0644, NULL,
+               &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_temp_tmin},
+       {ADM1026_SYSCTL_TEMP_TMIN2, "temp2_tmin", NULL, 0, 0644, NULL,
+               &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_temp_tmin},
+       {ADM1026_SYSCTL_TEMP_TMIN3, "temp3_tmin", NULL, 0, 0644, NULL,
+               &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_temp_tmin},
+       {ADM1026_SYSCTL_TEMP_THERM1, "temp1_therm", NULL, 0, 0644, NULL,
+               &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_temp_therm},
+       {ADM1026_SYSCTL_TEMP_THERM2, "temp2_therm", NULL, 0, 0644, NULL,
+               &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_temp_therm},
+       {ADM1026_SYSCTL_TEMP_THERM3, "temp3_therm", NULL, 0, 0644, NULL,
+               &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_temp_therm},
+
+       {ADM1026_SYSCTL_VID, "vid", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &adm1026_vid},
+       {ADM1026_SYSCTL_VRM, "vrm", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &adm1026_vrm},
+
+       {ADM1026_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &adm1026_alarms},
+       {ADM1026_SYSCTL_ALARM_MASK, "alarm_mask", NULL, 0, 0644, NULL,
+               &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_alarm_mask},
+
+       {ADM1026_SYSCTL_GPIO, "gpio", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &adm1026_gpio},
+       {ADM1026_SYSCTL_GPIO_MASK, "gpio_mask", NULL, 0, 0644, NULL,
+               &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_gpio_mask},
+
+       {ADM1026_SYSCTL_PWM, "pwm", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &adm1026_pwm},
+       {ADM1026_SYSCTL_ANALOG_OUT, "analog_out", NULL, 0, 0644, NULL,
+               &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1026_analog_out},
+       {ADM1026_SYSCTL_AFC, "afc", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &adm1026_afc},
+
+       {0}
+};
+#define CTLTBL_COMMON (sizeof(adm1026_common)/sizeof(adm1026_common[0]))
+
+#define MAX2(a,b) ((a)>(b)?(a):(b))
+#define MAX3(a,b,c) ((a)>(b)?MAX2((a),(c)):MAX2((b),(c)))
+#define MAX4(a,b,c,d) ((a)>(b)?MAX3((a),(c),(d)):MAX3((b),(c),(d)))
+
+#define CTLTBL_MAX (CTLTBL_COMMON)
+
+/* This function is called when:
+     * the module is loaded
+     * a new adapter is loaded
+ */
+int adm1026_attach_adapter(struct i2c_adapter *adapter)
+{
+       return i2c_detect(adapter, &addr_data, adm1026_detect);
+}
+
+/* This function is called by i2c_detect */
+int adm1026_detect(struct i2c_adapter *adapter, int address,
+               unsigned short flags, int kind)
+{
+       int i;
+       int company, verstep ;
+       struct i2c_client *new_client;
+       struct adm1026_data *data;
+       int err = 0;
+       const char *type_name = "";
+       struct ctl_table template[CTLTBL_MAX] ;
+       struct ctl_table * template_next = template ;
+
+       if (i2c_is_isa_adapter(adapter)) {
+               /* This chip has no ISA interface */
+               goto ERROR0 ;
+       }
+
+       if (!i2c_check_functionality(adapter,
+                                       I2C_FUNC_SMBUS_BYTE_DATA)) {
+               /* We need to be able to do byte I/O */
+               goto ERROR0 ;
+       }
+
+       /* OK. For now, we presume we have a valid client. We now create the
+          client structure, even though we cannot fill it completely yet.
+          But it allows us to access adm1026_{read,write}_value. */
+
+       if (!(data = kmalloc(sizeof(struct adm1026_data), GFP_KERNEL))) {
+               err = -ENOMEM;
+               goto ERROR0;
+       }
+
+       new_client = &data->client;
+       new_client->addr = address;
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &adm1026_driver;
+       new_client->flags = 0;
+
+       /* Now, we do the remaining detection. */
+
+       company = adm1026_read_value(new_client, ADM1026_REG_COMPANY);
+       verstep = adm1026_read_value(new_client, ADM1026_REG_VERSTEP);
+
+#ifdef DEBUG
+       printk("adm1026: Detecting device at %d,0x%02x with"
+               " COMPANY: 0x%02x and VERSTEP: 0x%02x\n",
+               i2c_adapter_id(new_client->adapter), new_client->addr,
+               company, verstep
+           );
+#endif
+
+       /* If auto-detecting, Determine the chip type. */
+       if (kind <= 0) {
+#ifdef DEBUG
+               printk("adm1026: Autodetecting device at %d,0x%02x ...\n",
+                       i2c_adapter_id(adapter), address );
+#endif
+               if( company == ADM1026_COMPANY_ANALOG_DEV
+                   && verstep == ADM1026_VERSTEP_ADM1026 ) {
+                       kind = adm1026 ;
+               } else if( company == ADM1026_COMPANY_ANALOG_DEV
+                   && (verstep & 0xf0) == ADM1026_VERSTEP_GENERIC ) {
+                       printk("adm1026: Unrecgonized stepping 0x%02x"
+                           " Defaulting to ADM1026.\n", verstep );
+                       kind = adm1026 ;
+               } else if( (verstep & 0xf0) == ADM1026_VERSTEP_GENERIC ) {
+                       printk("adm1026: Found version/stepping 0x%02x"
+                           " Assuming generic ADM1026.\n", verstep );
+                       kind = any_chip ;
+               } else {
+#ifdef DEBUG
+                       printk("adm1026: Autodetection failed\n");
+#endif
+                       /* Not an ADM1026 ... */
+                       if( kind == 0 ) {  /* User used force=x,y */
+                           printk("adm1026: Generic ADM1026 Version 6 not"
+                               " found at %d,0x%02x. Try force_adm1026.\n",
+                               i2c_adapter_id(adapter), address );
+                       }
+                       err = 0 ;
+                       goto ERROR1;
+               }
+       }
+
+       /* Fill in the chip specific driver values */
+       switch (kind) {
+       case any_chip :
+               type_name = "adm1026";
+               strcpy(new_client->name, "Generic ADM1026");
+               template_next = template ;  /* None used */
+               break ;
+       case adm1026 :
+               type_name = "adm1026";
+               strcpy(new_client->name, "Analog Devices ADM1026");
+               template_next = template ;
+               break ;
+#if 0
+       /* Example of another adm1026 "compatible" device */
+       case adx1000 :
+               type_name = "adx1000";
+               strcpy(new_client->name, "Compatible ADX1000");
+               memcpy( template, adx_specific, sizeof(adx_specific) );
+               template_next = template + CTLTBL_ADX1000 ;
+               break ;
+#endif
+       default :
+               printk("adm1026: Internal error, invalid kind (%d)!", kind);
+               err = -EFAULT ;
+               goto ERROR1;
+       }
+
+       /* Fill in the remaining client fields */
+       new_client->id = adm1026_id++;
+       printk("adm1026(%d): Assigning ID %d to %s at %d,0x%02x\n",
+               new_client->id, new_client->id, new_client->name,
+               i2c_adapter_id(new_client->adapter),
+               new_client->addr
+           );
+
+       /* Housekeeping values */
+       data->type = kind;
+       data->valid = 0;
+
+       /* Set the VRM version */
+       data->vrm = ADM1026_INIT_VRM ;
+       data->vid = ADM1026_INIT_VID ;
+
+       init_MUTEX(&data->update_lock);
+
+       /* Initialize the ADM1026 chip */
+       adm1026_init_client(new_client);
+
+       /* Tell the I2C layer a new client has arrived */
+       if ((err = i2c_attach_client(new_client)))
+               goto ERROR1;
+
+       /* Finish out the template */
+       memcpy(template_next, adm1026_common, sizeof(adm1026_common));
+
+       /* Register a new directory entry with module sensors */
+       if ((i = i2c_register_entry(new_client,
+                                       type_name,
+                                       template)) < 0) {
+               err = i;
+               goto ERROR2;
+       }
+       data->sysctl_id = i;
+
+       return 0;
+
+       /* Error out and cleanup code */
+    ERROR2:
+       i2c_detach_client(new_client);
+    ERROR1:
+       kfree(data);
+    ERROR0:
+       return err;
+}
+
+int adm1026_detach_client(struct i2c_client *client)
+{
+       int err;
+       int id ;
+
+       id = client->id;
+       i2c_deregister_entry(((struct adm1026_data *)(client->data))->sysctl_id);
+
+       if ((err = i2c_detach_client(client))) {
+               printk("adm1026(%d): Client deregistration failed,"
+                       " client not detached.\n", id );
+               return err;
+       }
+
+       kfree(client->data);
+
+       return 0;
+}
+
+int adm1026_read_value(struct i2c_client *client, u8 reg)
+{
+       int res;
+
+       if( reg < 0x80 ) {
+               /* "RAM" locations */
+               res = i2c_smbus_read_byte_data(client, reg) & 0xff ;
+       } else {
+               /* EEPROM, do nothing */
+               res = 0 ;
+       }
+
+       return res ;
+}
+
+int adm1026_write_value(struct i2c_client *client, u8 reg, int value)
+{
+       int res ;
+
+       if( reg < 0x80 ) {
+               /* "RAM" locations */
+               res = i2c_smbus_write_byte_data(client, reg, value);
+       } else {
+               /* EEPROM, do nothing */
+               res = 0 ;
+       }
+
+       return res ;
+}
+
+/* Called when we have found a new ADM1026. */
+void adm1026_init_client(struct i2c_client *client)
+{
+       int value ;
+       int i;
+       struct adm1026_data *data = client->data;
+
+#ifdef DEBUG
+       printk("adm1026(%d): Initializing device\n", client->id);
+#endif
+
+       /* Read chip config */
+       data->config1 = adm1026_read_value(client, ADM1026_REG_CONFIG1);
+       data->config2 = adm1026_read_value(client, ADM1026_REG_CONFIG2);
+       data->config3 = adm1026_read_value(client, ADM1026_REG_CONFIG3);
+
+       /* Inform user of chip config */
+#ifdef DEBUG
+       printk("adm1026(%d): ADM1026_REG_CONFIG1 is: 0x%02x\n",
+               client->id, data->config1 );
+#endif
+       if( (data->config1 & CFG1_MONITOR) == 0 ) {
+               printk("adm1026(%d): Monitoring not currently enabled.\n",
+                           client->id );
+       }
+       if( data->config1 & CFG1_INT_ENABLE ) {
+               printk("adm1026(%d): SMBALERT interrupts are enabled.\n",
+                           client->id );
+       }
+       if( data->config1 & CFG1_AIN8_9 ) {
+               printk("adm1026(%d): in8 and in9 enabled.  temp3 disabled.\n",
+                           client->id );
+       } else {
+               printk("adm1026(%d): temp3 enabled.  in8 and in9 disabled.\n",
+                           client->id );
+       }
+       if( data->config1 & CFG1_THERM_HOT ) {
+               printk("adm1026(%d): Automatic THERM, PWM, and temp limits enabled.\n",
+                           client->id );
+       }
+
+       value = data->config3 ;
+       if( data->config3 & CFG3_GPIO16_ENABLE ) {
+               printk("adm1026(%d): GPIO16 enabled.  THERM pin disabled.\n",
+                           client->id );
+       } else {
+               printk("adm1026(%d): THERM pin enabled.  GPIO16 disabled.\n",
+                           client->id );
+       }
+       if( data->config3 & CFG3_VREF_250 ) {
+               printk("adm1026(%d): Vref is 2.50 Volts.\n", client->id );
+       } else {
+               printk("adm1026(%d): Vref is 1.82 Volts.\n", client->id );
+       }
+
+       /* Read and pick apart the existing GPIO configuration */
+       value = 0 ;
+       for( i = 0 ; i <= 15 ; ++i ) {
+               if( (i & 0x03) == 0 ) {
+                       value = adm1026_read_value(client,
+                                       ADM1026_REG_GPIO_CFG_0_3 + i/4 );
+               }
+               data->gpio_config[i] = value & 0x03 ;
+               value >>= 2 ;
+       }
+       data->gpio_config[16] = (data->config3 >> 6) & 0x03 ;
+
+       /* ... and then print it */
+       adm1026_print_gpio(client);
+
+       /* If the user asks us to reprogram the GPIO config, then
+        *   do it now.  But only if this is the first ADM1026.
+        */
+       if( client->id == 0
+           && (gpio_input[0] != -1 || gpio_output[0] != -1
+               || gpio_inverted[0] != -1 || gpio_normal[0] != -1
+               || gpio_fan[0] != -1 ) ) {
+               adm1026_fixup_gpio(client);
+       }
+
+       /* WE INTENTIONALLY make no changes to the limits,
+        *   offsets, pwms and fans.  If they were
+        *   configured, we don't want to mess with them.
+        *   If they weren't, the default is generally safe
+        *   and will suffice until 'sensors -s' can be run.
+        */
+
+       /* Start monitoring */
+       value = adm1026_read_value(client, ADM1026_REG_CONFIG1);
+
+       /* Set MONITOR, clear interrupt acknowledge and s/w reset */
+       value = (value | CFG1_MONITOR) & (~CFG1_INT_CLEAR & ~CFG1_RESET) ;
+#ifdef DEBUG
+       printk("adm1026(%d): Setting CONFIG to: 0x%02x\n", client->id, value );
+#endif
+       data->config1 = value ;
+       adm1026_write_value(client, ADM1026_REG_CONFIG1, value);
+
+}
+
+void adm1026_print_gpio(struct i2c_client *client)
+{
+       struct adm1026_data *data = client->data;
+       int  i ;
+
+       printk("adm1026(%d): GPIO config is:\nadm1026(%d):",
+                           client->id, client->id );
+       for( i = 0 ; i <= 7 ; ++i ) {
+               if( data->config2 & (1 << i) ) {
+                       printk( " %sGP%s%d",
+                               data->gpio_config[i] & 0x02 ? "" : "!",
+                               data->gpio_config[i] & 0x01 ? "OUT" : "IN",
+                               i );
+               } else {
+                       printk( " FAN%d", i );
+               }
+       }
+       printk( "\nadm1026(%d):", client->id );
+       for( i = 8 ; i <= 15 ; ++i ) {
+               printk( " %sGP%s%d",
+                       data->gpio_config[i] & 0x02 ? "" : "!",
+                       data->gpio_config[i] & 0x01 ? "OUT" : "IN",
+                       i );
+       }
+       if( data->config3 & CFG3_GPIO16_ENABLE ) {
+               printk( " %sGP%s16\n",
+                       data->gpio_config[16] & 0x02 ? "" : "!",
+                       data->gpio_config[16] & 0x01 ? "OUT" : "IN" );
+       } else {
+               /* GPIO16 is THERM */
+               printk( " THERM\n" );
+       }
+}
+
+void adm1026_fixup_gpio(struct i2c_client *client)
+{
+       struct adm1026_data *data = client->data;
+       int  i ;
+       int  value ;
+
+       /* Make the changes requested. */
+       /* We may need to unlock/stop monitoring or soft-reset the
+        *    chip before we can make changes.  This hasn't been
+        *    tested much.  FIXME
+        */
+
+       /* Make outputs */
+       for( i = 0 ; i <= 16 ; ++i ) {
+               if( gpio_output[i] >= 0 && gpio_output[i] <= 16 ) {
+                       data->gpio_config[gpio_output[i]] |= 0x01 ;
+               }
+               /* if GPIO0-7 is output, it isn't a FAN tach */
+               if( gpio_output[i] >= 0 && gpio_output[i] <= 7 ) {
+                       data->config2 |= 1 << gpio_output[i] ;
+               }
+       }
+
+       /* Input overrides output */
+       for( i = 0 ; i <= 16 ; ++i ) {
+               if( gpio_input[i] >= 0 && gpio_input[i] <= 16 ) {
+                       data->gpio_config[gpio_input[i]] &= ~ 0x01 ;
+               }
+               /* if GPIO0-7 is input, it isn't a FAN tach */
+               if( gpio_input[i] >= 0 && gpio_input[i] <= 7 ) {
+                       data->config2 |= 1 << gpio_input[i] ;
+               }
+       }
+
+       /* Inverted  */
+       for( i = 0 ; i <= 16 ; ++i ) {
+               if( gpio_inverted[i] >= 0 && gpio_inverted[i] <= 16 ) {
+                       data->gpio_config[gpio_inverted[i]] &= ~ 0x02 ;
+               }
+       }
+
+       /* Normal overrides inverted  */
+       for( i = 0 ; i <= 16 ; ++i ) {
+               if( gpio_normal[i] >= 0 && gpio_normal[i] <= 16 ) {
+                       data->gpio_config[gpio_normal[i]] |= 0x02 ;
+               }
+       }
+
+       /* Fan overrides input and output */
+       for( i = 0 ; i <= 7 ; ++i ) {
+               if( gpio_fan[i] >= 0 && gpio_fan[i] <= 7 ) {
+                       data->config2 &= ~( 1 << gpio_fan[i] );
+               }
+       }
+
+       /* Write new configs to registers */
+       adm1026_write_value(client, ADM1026_REG_CONFIG2, data->config2);
+       data->config3 = (data->config3 & 0x3f)
+                       | ((data->gpio_config[16] & 0x03) << 6) ;
+       adm1026_write_value(client, ADM1026_REG_CONFIG3, data->config3);
+       for( i = 15, value = 0 ; i >= 0 ; --i ) {
+               value <<= 2 ;
+               value |= data->gpio_config[i] & 0x03 ;
+               if( (i & 0x03) == 0 ) {
+                       adm1026_write_value(client,
+                                       ADM1026_REG_GPIO_CFG_0_3 + i/4,
+                                       value );
+                       value = 0 ;
+               }
+       }
+
+       /* Print the new config */
+       adm1026_print_gpio(client);
+}
+
+void adm1026_update_client(struct i2c_client *client)
+{
+       struct adm1026_data *data = client->data;
+       int i;
+       long value, alarms, gpio ;
+
+       down(&data->update_lock);
+
+       if (!data->valid
+           || (jiffies - data->last_reading > ADM1026_DATA_INTERVAL )) {
+               /* Things that change quickly */
+
+#ifdef DEBUG
+               printk("adm1026(%d): Reading sensor values\n", client->id);
+#endif
+               for (i = 0 ; i <= 16 ; ++i) {
+                       data->in[i] =
+                           adm1026_read_value(client, ADM1026_REG_IN(i));
+               }
+
+               for (i = 0 ; i <= 7 ; ++i) {
+                       data->fan[i] =
+                           adm1026_read_value(client, ADM1026_REG_FAN(i));
+               }
+
+               for (i = 0 ; i <= 2 ; ++i) {
+                       /* NOTE: temp[] is s8 and we assume 2's complement
+                        *   "conversion" in the assignment   */
+                       data->temp[i] =
+                           adm1026_read_value(client, ADM1026_REG_TEMP(i));
+               }
+
+               data->pwm = adm1026_read_value(client, ADM1026_REG_PWM);
+               data->analog_out = adm1026_read_value(client, ADM1026_REG_DAC);
+
+               /* GPIO16 is MSbit of alarms, move it to gpio */
+               alarms  = adm1026_read_value(client, ADM1026_REG_STATUS4);
+               gpio = alarms & 0x80 ? 0x0100 : 0 ;  /* GPIO16 */
+               alarms &= 0x7f ;
+               alarms <<= 8 ;
+               alarms |= adm1026_read_value(client, ADM1026_REG_STATUS3);
+               alarms <<= 8 ;
+               alarms |= adm1026_read_value(client, ADM1026_REG_STATUS2);
+               alarms <<= 8 ;
+               alarms |= adm1026_read_value(client, ADM1026_REG_STATUS1);
+               data->alarms = alarms ;
+
+               /* Read the GPIO values */
+               gpio |= adm1026_read_value(client, ADM1026_REG_GPIO_STATUS_8_15);
+               gpio <<= 8 ;
+               gpio |= adm1026_read_value(client, ADM1026_REG_GPIO_STATUS_0_7);
+               data->gpio = gpio ;
+
+               data->last_reading = jiffies ;
+       };  /* last_reading */
+
+       if (!data->valid
+           || (jiffies - data->last_config > ADM1026_CONFIG_INTERVAL) ) {
+               /* Things that don't change often */
+
+#ifdef DEBUG
+               printk("adm1026(%d): Reading config values\n", client->id);
+#endif
+               for (i = 0 ; i <= 16 ; ++i) {
+                       data->in_min[i] =
+                           adm1026_read_value(client, ADM1026_REG_IN_MIN(i));
+                       data->in_max[i] =
+                           adm1026_read_value(client, ADM1026_REG_IN_MAX(i));
+               }
+
+               value = adm1026_read_value(client, ADM1026_REG_FAN_DIV_0_3)
+                       | (adm1026_read_value(client, ADM1026_REG_FAN_DIV_4_7) << 8);
+               for (i = 0 ; i <= 7 ; ++i) {
+                       data->fan_min[i] =
+                           adm1026_read_value(client, ADM1026_REG_FAN_MIN(i));
+                       data->fan_div[i] = DIV_FROM_REG(value & 0x03);
+                       value >>= 2 ;
+               }
+
+               for (i = 0; i <= 2; ++i) {
+                       /* NOTE: temp_xxx[] are s8 and we assume 2's complement
+                        *   "conversion" in the assignment   */
+                       data->temp_min[i] =
+                           adm1026_read_value(client, ADM1026_REG_TEMP_MIN(i));
+                       data->temp_max[i] =
+                           adm1026_read_value(client, ADM1026_REG_TEMP_MAX(i));
+                       data->temp_tmin[i] =
+                           adm1026_read_value(client, ADM1026_REG_TEMP_TMIN(i));
+                       data->temp_therm[i] =
+                           adm1026_read_value(client, ADM1026_REG_TEMP_THERM(i));
+                       data->temp_offset[i] =
+                           adm1026_read_value(client, ADM1026_REG_TEMP_OFFSET(i));
+               }
+
+               /* Read the STATUS/alarm masks */
+               alarms  = adm1026_read_value(client, ADM1026_REG_MASK4);
+               gpio    = alarms & 0x80 ? 0x0100 : 0 ;  /* GPIO16 */
+               alarms  = (alarms & 0x7f) << 8 ;
+               alarms |= adm1026_read_value(client, ADM1026_REG_MASK3);
+               alarms <<= 8 ;
+               alarms |= adm1026_read_value(client, ADM1026_REG_MASK2);
+               alarms <<= 8 ;
+               alarms |= adm1026_read_value(client, ADM1026_REG_MASK1);
+               data->alarm_mask = alarms ;
+
+               /* Read the GPIO values */
+               gpio |= adm1026_read_value(client, ADM1026_REG_GPIO_MASK_8_15);
+               gpio <<= 8 ;
+               gpio |= adm1026_read_value(client, ADM1026_REG_GPIO_MASK_0_7);
+               data->gpio_mask = gpio ;
+
+               /* Read the GPIO config */
+               data->config2 = adm1026_read_value(client, ADM1026_REG_CONFIG2);
+               data->config3 = adm1026_read_value(client, ADM1026_REG_CONFIG3);
+               data->gpio_config[16] = (data->config3 >> 6) & 0x03 ;
+
+               value = 0 ;
+               for( i = 0 ; i <= 15 ; ++i ) {
+                       if( (i & 0x03) == 0 ) {
+                               value = adm1026_read_value(client,
+                                           ADM1026_REG_GPIO_CFG_0_3 + i/4 );
+                       }
+                       data->gpio_config[i] = value & 0x03 ;
+                       value >>= 2 ;
+               }
+
+               data->last_config = jiffies;
+       };  /* last_config */
+
+       /* We don't know where or even _if_ the VID might be on the GPIO
+        *    pins.  But the datasheet gives an example config showing
+        *    GPIO11-15 being used to monitor VID0-4, so we go with that
+        *    but make the vid WRITEABLE so if it's wrong, the user can
+        *    set it in /etc/sensors.conf perhaps using an expression or
+        *    0 to trigger a re-read from the GPIO pins.
+        */
+       if( data->vid == ADM1026_INIT_VID ) {
+               /* Hasn't been set yet, make a bold assumption */
+               printk("adm1026(%d): Setting VID from GPIO11-15.\n",
+                           client->id );
+               data->vid = (data->gpio >> 11) & 0x1f ;
+       }
+       
+       data->valid = 1;
+
+       up(&data->update_lock);
+}
+
+
+/* The following functions are the call-back functions of the /proc/sys and
+   sysctl files.  The appropriate function is referenced in the ctl_table
+   extra1 field.
+
+   Each function must return the magnitude (power of 10 to divide the
+   data with) if it is called with operation set to SENSORS_PROC_REAL_INFO.
+   It must put a maximum of *nrels elements in results reflecting the
+   data of this file, and set *nrels to the number it actually put in
+   it, if operation is SENSORS_PROC_REAL_READ.  Finally, it must get
+   up to *nrels elements from results and write them to the chip, if
+   operations is SENSORS_PROC_REAL_WRITE.
+ */
+void adm1026_in(struct i2c_client *client, int operation, int ctl_name,
+            int *nrels_mag, long *results)
+{
+       struct adm1026_data *data = client->data;
+       int nr = ctl_name - ADM1026_SYSCTL_IN0;
+
+       /* We handle in0 - in15 here.  in16 (-12V) is handled below */
+       if (nr < 0 || nr > 15)
+               return ;  /* ERROR */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 3;  /* 1.000 */
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm1026_update_client(client);
+               results[0] = INS_FROM_REG(nr,data->in_min[nr]);
+               results[1] = INS_FROM_REG(nr,data->in_max[nr]);
+               results[2] = INS_FROM_REG(nr,data->in[nr]);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               down(&data->update_lock);
+               if (*nrels_mag > 1) {
+                       data->in_max[nr] = INS_TO_REG(nr,results[1]);
+                       adm1026_write_value(client, ADM1026_REG_IN_MAX(nr),
+                                        data->in_max[nr]);
+               }
+               if (*nrels_mag > 0) {
+                       data->in_min[nr] = INS_TO_REG(nr,results[0]);
+                       adm1026_write_value(client, ADM1026_REG_IN_MIN(nr),
+                                        data->in_min[nr]);
+               }
+               up(&data->update_lock);
+       }
+}
+
+void adm1026_in16(struct i2c_client *client, int operation, int ctl_name,
+            int *nrels_mag, long *results)
+{
+       struct adm1026_data *data = client->data;
+       int nr = ctl_name - ADM1026_SYSCTL_IN0;
+
+       /* We handle in16 (-12V) here */
+       if (nr != 16)
+               return ;  /* ERROR */
+
+       /* Apply offset and swap min/max so that min is 90% of
+        *    target and max is 110% of target.
+        */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 3;  /* 1.000 */
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm1026_update_client(client);
+               results[0] = INS_FROM_REG(nr,data->in_max[nr])-NEG12_OFFSET ;
+               results[1] = INS_FROM_REG(nr,data->in_min[nr])-NEG12_OFFSET ;
+               results[2] = INS_FROM_REG(nr,data->in[nr])-NEG12_OFFSET ;
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               down(&data->update_lock);
+               if (*nrels_mag > 1) {
+                       data->in_min[nr] = INS_TO_REG(nr,results[1]+NEG12_OFFSET);
+                       adm1026_write_value(client, ADM1026_REG_IN_MIN(nr),
+                                        data->in_min[nr]);
+               }
+               if (*nrels_mag > 0) {
+                       data->in_max[nr] = INS_TO_REG(nr,results[0]+NEG12_OFFSET);
+                       adm1026_write_value(client, ADM1026_REG_IN_MAX(nr),
+                                        data->in_max[nr]);
+               }
+               up(&data->update_lock);
+       }
+}
+
+void adm1026_fan(struct i2c_client *client, int operation, int ctl_name,
+             int *nrels_mag, long *results)
+{
+       struct adm1026_data *data = client->data;
+       int nr = ctl_name - ADM1026_SYSCTL_FAN0 ;
+
+       if (nr < 0 || nr > 7)
+               return ;  /* ERROR */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm1026_update_client(client);
+               results[0] = FAN_FROM_REG(data->fan_min[nr], data->fan_div[nr]);
+               results[1] = FAN_FROM_REG(data->fan[nr], data->fan_div[nr]);
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               down(&data->update_lock);
+               if (*nrels_mag > 0) {
+                       data->fan_min[nr] = FAN_TO_REG(results[0],
+                                                       data->fan_div[nr]);
+                       adm1026_write_value(client, ADM1026_REG_FAN_MIN(nr),
+                                        data->fan_min[nr]);
+               }
+               up(&data->update_lock);
+       }
+}
+
+/* Adjust fan_min to account for new fan divisor */
+void adm1026_fixup_fan_min(struct i2c_client *client, int fan, int old_div)
+{
+       struct adm1026_data *data = client->data;
+       int  new_div = data->fan_div[fan] ;
+       int  new_min;
+
+       /* 0 and 0xff are special.  Don't adjust them */
+       if( data->fan_min[fan] == 0 || data->fan_min[fan] == 0xff ) {
+               return ;
+       }
+
+       new_min = data->fan_min[fan] * old_div / new_div ;
+       new_min = SENSORS_LIMIT(new_min, 1, 254);
+       data->fan_min[fan] = new_min ;
+       adm1026_write_value(client, ADM1026_REG_FAN_MIN(fan), new_min);
+}
+
+void adm1026_fan_div(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       struct adm1026_data *data = client->data;
+       int i ;
+       int value, div, old ;
+
+       if (ctl_name != ADM1026_SYSCTL_FAN_DIV)
+               return ;  /* ERROR */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm1026_update_client(client);
+               for( i = 0 ; i <= 7 ; ++i ) {
+                       results[i] = data->fan_div[i] ;
+               }
+               *nrels_mag = 8;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               down(&data->update_lock);
+               value = 0 ;
+               for( i = 7 ; i >= 0 ; --i ) {
+                       value <<= 2 ;
+                       if (*nrels_mag > i) {
+                               old = data->fan_div[i] ;
+                               div = DIV_TO_REG(results[i]) ;
+                               data->fan_div[i] = DIV_FROM_REG(div) ;
+                               if( data->fan_div[i] != old ) {
+                                       adm1026_fixup_fan_min(client,i,old);
+                               }
+                       } else {
+                               div = DIV_TO_REG(data->fan_div[i]) ;
+                       }
+                       value |= div ;
+               }
+               adm1026_write_value(client, ADM1026_REG_FAN_DIV_0_3,
+                       value & 0xff);
+               adm1026_write_value(client, ADM1026_REG_FAN_DIV_4_7,
+                       (value >> 8) & 0xff);
+               up(&data->update_lock);
+       }
+}
+
+void adm1026_temp(struct i2c_client *client, int operation, int ctl_name,
+              int *nrels_mag, long *results)
+{
+       struct adm1026_data *data = client->data;
+       int nr = ctl_name - ADM1026_SYSCTL_TEMP1 ;
+
+       if (nr < 0 || nr > 2)
+               return ;  /* ERROR */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm1026_update_client(client);
+               results[0] = TEMP_FROM_REG(data->temp_min[nr]);
+               results[1] = TEMP_FROM_REG(data->temp_max[nr]);
+               results[2] = TEMP_FROM_REG(data->temp[nr]);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               down(&data->update_lock);
+               if (*nrels_mag > 1) {
+                       data->temp_max[nr] = TEMP_TO_REG(results[1]);
+                       adm1026_write_value(client, ADM1026_REG_TEMP_MAX(nr),
+                                        data->temp_max[nr]);
+               }
+               if (*nrels_mag > 0) {
+                       data->temp_min[nr] = TEMP_TO_REG(results[0]);
+                       adm1026_write_value(client, ADM1026_REG_TEMP_MIN(nr),
+                                        data->temp_min[nr]);
+               }
+               up(&data->update_lock);
+       }
+}
+
+void adm1026_temp_offset(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       struct adm1026_data *data = client->data;
+       int nr = ctl_name - ADM1026_SYSCTL_TEMP_OFFSET1 ;
+
+       if (nr < 0 || nr > 2)
+               return ;  /* ERROR */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm1026_update_client(client);
+               results[0] = TEMP_FROM_REG(data->temp_offset[nr]);
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               down(&data->update_lock);
+               if (*nrels_mag > 0) {
+                       data->temp_offset[nr] = TEMP_TO_REG(results[0]);
+                       adm1026_write_value(client, ADM1026_REG_TEMP_OFFSET(nr),
+                           data->temp_offset[nr]);
+               }
+               up(&data->update_lock);
+       }
+}
+
+void adm1026_temp_tmin(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       struct adm1026_data *data = client->data;
+       int nr = ctl_name - ADM1026_SYSCTL_TEMP_TMIN1 ;
+
+       if (nr < 0 || nr > 2)
+               return ;  /* ERROR */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm1026_update_client(client);
+               results[0] = TEMP_FROM_REG(data->temp_tmin[nr]);
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               down(&data->update_lock);
+               if (*nrels_mag > 0) {
+                       data->temp_tmin[nr] = TEMP_TO_REG(results[0]);
+                       adm1026_write_value(client, ADM1026_REG_TEMP_TMIN(nr),
+                           data->temp_tmin[nr]);
+               }
+               up(&data->update_lock);
+       }
+}
+
+void adm1026_temp_therm(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       struct adm1026_data *data = client->data;
+       int nr = ctl_name - ADM1026_SYSCTL_TEMP_THERM1 ;
+
+       if (nr < 0 || nr > 2)
+               return ;  /* ERROR */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm1026_update_client(client);
+               results[0] = TEMP_FROM_REG(data->temp_therm[nr]);
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               down(&data->update_lock);
+               if (*nrels_mag > 0) {
+                       data->temp_therm[nr] = TEMP_TO_REG(results[0]);
+                       adm1026_write_value(client, ADM1026_REG_TEMP_THERM(nr),
+                           data->temp_therm[nr]);
+               }
+               up(&data->update_lock);
+       }
+}
+
+void adm1026_pwm(struct i2c_client *client, int operation, int ctl_name,
+             int *nrels_mag, long *results)
+{
+       struct adm1026_data *data = client->data;
+
+       if (ctl_name != ADM1026_SYSCTL_PWM)
+               return ;  /* ERROR */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm1026_update_client(client);
+               results[0] = PWM_FROM_REG(data->pwm);
+               results[1] = 1 ;  /* Always enabled */
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               down(&data->update_lock);
+               /* PWM enable is read-only */
+               if (*nrels_mag > 0) {
+                       data->pwm = PWM_TO_REG(results[0]);
+                       adm1026_write_value(client, ADM1026_REG_PWM,
+                                        data->pwm);
+               }
+               up(&data->update_lock);
+       }
+}
+
+void adm1026_analog_out(struct i2c_client *client, int operation, int ctl_name,
+             int *nrels_mag, long *results)
+{
+       struct adm1026_data *data = client->data;
+
+       if (ctl_name != ADM1026_SYSCTL_ANALOG_OUT)
+               return ;  /* ERROR */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;  /* 0 - 255 */
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm1026_update_client(client);
+               results[0] = DAC_FROM_REG(data->analog_out);
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               down(&data->update_lock);
+               if (*nrels_mag > 0) {
+                       data->analog_out = DAC_TO_REG(results[0]);
+                       adm1026_write_value(client, ADM1026_REG_DAC,
+                                        data->analog_out);
+               }
+               up(&data->update_lock);
+       }
+}
+
+void adm1026_afc(struct i2c_client *client, int operation, int ctl_name,
+             int *nrels_mag, long *results)
+{
+       struct adm1026_data *data = client->data;
+
+       if (ctl_name != ADM1026_SYSCTL_AFC)
+               return ;  /* ERROR */
+
+       /* PWM auto fan control, DAC auto fan control */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm1026_update_client(client);
+               results[0] = (data->config1 & CFG1_PWM_AFC) != 0 ;
+               results[1] = (data->config1 & CFG1_DAC_AFC) != 0 ;
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               down(&data->update_lock);
+               if (*nrels_mag > 1) {
+                       data->config1 = (data->config1 & ~CFG1_DAC_AFC)
+                               | (results[1] ? CFG1_DAC_AFC : 0) ;
+               }
+               if (*nrels_mag > 0) {
+                       data->config1 = (data->config1 & ~CFG1_PWM_AFC)
+                               | (results[0] ? CFG1_PWM_AFC : 0) ;
+                       adm1026_write_value(client, ADM1026_REG_CONFIG1,
+                                        data->config1);
+               }
+               up(&data->update_lock);
+       }
+}
+
+void adm1026_vid(struct i2c_client *client, int operation, int ctl_name,
+             int *nrels_mag, long *results)
+{
+       struct adm1026_data *data = client->data;
+
+       if( ctl_name != ADM1026_SYSCTL_VID )
+               return ;  /* ERROR */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 3;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm1026_update_client(client);
+               results[0] = VID_FROM_REG((data->vid)&0x3f,data->vrm);
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               down(&data->update_lock);
+               /* Hmmm... There isn't a VID_TO_REG mapping */
+               if (*nrels_mag > 0) {
+                       if( results[0] >= 0 ) {
+                               data->vid = results[0] & 0x3f ;
+                       } else {
+                               data->vid = ADM1026_INIT_VID ;
+                       }
+               }
+               up(&data->update_lock);
+       }
+
+}
+
+void adm1026_vrm(struct i2c_client *client, int operation, int ctl_name,
+             int *nrels_mag, long *results)
+{
+       struct adm1026_data *data = client->data;
+
+       if( ctl_name != ADM1026_SYSCTL_VRM )
+               return ;  /* ERROR */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               results[0] = data->vrm ;
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag > 0) {
+                       data->vrm = results[0] ;
+               }
+       }
+}
+
+void adm1026_alarms(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       struct adm1026_data *data = client->data;
+
+       if( ctl_name != ADM1026_SYSCTL_ALARMS )
+               return ;  /* ERROR */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm1026_update_client(client);
+               results[0] = data->alarms ;
+               *nrels_mag = 1;
+       }
+       /* FIXME: Perhaps we should implement a write function
+        *   to clear an alarm?
+        */
+}
+
+void adm1026_alarm_mask(struct i2c_client *client, int operation,
+               int ctl_name, int *nrels_mag, long *results)
+{
+       struct adm1026_data *data = client->data;
+       unsigned long mask ;
+
+       if( ctl_name != ADM1026_SYSCTL_ALARM_MASK )
+               return ;  /* ERROR */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm1026_update_client(client);
+               results[0] = data->alarm_mask ;
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               down(&data->update_lock);
+               if (*nrels_mag > 0) {
+                       data->alarm_mask = results[0] & 0x7fffffff ;
+                       mask = data->alarm_mask
+                               | (data->gpio_mask & 0x10000 ? 0x80000000 : 0) ;
+                       adm1026_write_value(client, ADM1026_REG_MASK1,
+                                       mask & 0xff);
+                       mask >>= 8 ;
+                       adm1026_write_value(client, ADM1026_REG_MASK2,
+                                       mask & 0xff);
+                       mask >>= 8 ;
+                       adm1026_write_value(client, ADM1026_REG_MASK3,
+                                       mask & 0xff);
+                       mask >>= 8 ;
+                       adm1026_write_value(client, ADM1026_REG_MASK4,
+                                       mask & 0xff);
+               }
+               up(&data->update_lock);
+       }
+}
+
+void adm1026_gpio(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       struct adm1026_data *data = client->data;
+       long gpio ;
+
+       if( ctl_name != ADM1026_SYSCTL_GPIO )
+               return ;  /* ERROR */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm1026_update_client(client);
+               results[0] = data->gpio ;
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               down(&data->update_lock);
+               if (*nrels_mag > 0) {
+                       data->gpio = results[0] & 0x1ffff ;
+                       gpio = data->gpio ;
+                       adm1026_write_value(client,
+                               ADM1026_REG_GPIO_STATUS_0_7,
+                               gpio & 0xff );
+                       gpio >>= 8 ;
+                       adm1026_write_value(client,
+                               ADM1026_REG_GPIO_STATUS_8_15,
+                               gpio & 0xff );
+                       gpio = ((gpio >> 1) & 0x80)
+                               | (data->alarms >> 24 & 0x7f);
+                       adm1026_write_value(client,
+                               ADM1026_REG_STATUS4,
+                               gpio & 0xff );
+               }
+               up(&data->update_lock);
+       }
+}
+
+void adm1026_gpio_mask(struct i2c_client *client, int operation,
+               int ctl_name, int *nrels_mag, long *results)
+{
+       struct adm1026_data *data = client->data;
+       long mask ;
+
+       if( ctl_name != ADM1026_SYSCTL_GPIO_MASK )
+               return ;  /* ERROR */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm1026_update_client(client);
+               results[0] = data->gpio_mask ;
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               down(&data->update_lock);
+               if (*nrels_mag > 0) {
+                       data->gpio_mask = results[0] & 0x1ffff ;
+                       mask = data->gpio_mask ;
+                       adm1026_write_value(client, ADM1026_REG_GPIO_MASK_0_7,
+                                       mask & 0xff);
+                       mask >>= 8 ;
+                       adm1026_write_value(client, ADM1026_REG_GPIO_MASK_8_15,
+                                       mask & 0xff);
+                       mask = ((mask >> 1) & 0x80)
+                               | (data->alarm_mask >> 24 & 0x7f);
+                       adm1026_write_value(client, ADM1026_REG_MASK1,
+                                       mask & 0xff);
+               }
+               up(&data->update_lock);
+       }
+}
+
+static int __init sm_adm1026_init(void)
+{
+       printk("adm1026: Version %s (%s)\n", LM_VERSION, LM_DATE);
+       printk("adm1026: See http://www.penguincomputing.com/lm_sensors for more info.\n" );
+       return i2c_add_driver(&adm1026_driver);
+}
+
+static void __exit sm_adm1026_exit(void)
+{
+       i2c_del_driver(&adm1026_driver);
+}
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Philip Pokorny <ppokorny@penguincomputing.com");
+MODULE_DESCRIPTION("ADM1026 driver");
+
+module_init(sm_adm1026_init);
+module_exit(sm_adm1026_exit);
--- linux-old/drivers/sensors/adm9240.c Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/adm9240.c     Mon Dec 13 20:18:44 2004
@@ -0,0 +1,713 @@
+/*
+    adm9240.c - Part of lm_sensors, Linux kernel modules for hardware
+             monitoring
+    Copyright (C) 1999  Frodo Looijaard <frodol@dds.nl>
+    and Philip Edelbrock <phil@netroedge.com>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or 
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/* Supports ADM9240, DS1780, and LM81. See doc/chips/adm9240 for details */
+
+/* 
+       A couple notes about the ADM9240:
+
+* It claims to be 'LM7x' register compatible.  This must be in reference
+  to only the LM78, because it is missing stuff to emulate LM75's as well. 
+  (like the Winbond W83781 does)
+ 
+* This driver was written from rev. 0 of the PDF, but it seems well 
+  written and complete (unlike the W83781 which is horrible and has
+  supposidly gone through a few revisions.. rev 0 of that one must
+  have been in crayon on construction paper...)
+  
+* All analog inputs can range from 0 to 2.5, eventhough some inputs are
+  marked as being 5V, 12V, etc.  I don't have any real voltages going 
+  into my prototype, so I'm not sure that things are computed right, 
+  but at least the limits seem to be working OK.
+  
+* Another curiousity is that the fan_div seems to be read-only.  I.e.,
+  any written value to it doesn't seem to make any difference.  The
+  fan_div seems to be 'stuck' at 2 (which isn't a bad value in most cases).
+  
+  
+  --Phil
+
+*/
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = { SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { 0x2c, 0x2f, SENSORS_I2C_END };
+static unsigned int normal_isa[] = { SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+/* Insmod parameters */
+SENSORS_INSMOD_3(adm9240, ds1780, lm81);
+
+/* Many ADM9240 constants specified below */
+
+#define ADM9240_REG_IN_MAX(nr) (0x2b + (nr) * 2)
+#define ADM9240_REG_IN_MIN(nr) (0x2c + (nr) * 2)
+#define ADM9240_REG_IN(nr) (0x20 + (nr))
+
+/* The ADM9240 registers */
+#define ADM9240_REG_TEST 0x15
+#define ADM9240_REG_ANALOG_OUT 0x19
+/* These are all read-only */
+#define ADM9240_REG_2_5V 0x20
+#define ADM9240_REG_VCCP1 0x21
+#define ADM9240_REG_3_3V 0x22
+#define ADM9240_REG_5V 0x23
+#define ADM9240_REG_12V 0x24
+#define ADM9240_REG_VCCP2 0x25
+#define ADM9240_REG_TEMP 0x27
+#define ADM9240_REG_FAN1 0x28
+#define ADM9240_REG_FAN2 0x29
+#define ADM9240_REG_COMPANY_ID 0x3E    /* 0x23 for ADM9240; 0xDA for DS1780 */
+                                    /* 0x01 for LM81 */
+#define ADM9240_REG_DIE_REV 0x3F
+/* These are read/write */
+#define ADM9240_REG_2_5V_HIGH 0x2B
+#define ADM9240_REG_2_5V_LOW 0x2C
+#define ADM9240_REG_VCCP1_HIGH 0x2D
+#define ADM9240_REG_VCCP1_LOW 0x2E
+#define ADM9240_REG_3_3V_HIGH 0x2F
+#define ADM9240_REG_3_3V_LOW 0x30
+#define ADM9240_REG_5V_HIGH 0x31
+#define ADM9240_REG_5V_LOW 0x32
+#define ADM9240_REG_12V_HIGH 0x33
+#define ADM9240_REG_12V_LOW 0x34
+#define ADM9240_REG_VCCP2_HIGH 0x35
+#define ADM9240_REG_VCCP2_LOW 0x36
+#define ADM9240_REG_TCRIT_LIMIT 0x37   /* LM81 only - not supported */
+#define ADM9240_REG_LOW_LIMIT 0x38     /* LM81 only - not supported */
+#define ADM9240_REG_TOS 0x39
+#define ADM9240_REG_THYST 0x3A
+#define ADM9240_REG_FAN1_MIN 0x3B
+#define ADM9240_REG_FAN2_MIN 0x3C
+
+#define ADM9240_REG_CONFIG 0x40
+#define ADM9240_REG_INT1_STAT 0x41
+#define ADM9240_REG_INT2_STAT 0x42
+#define ADM9240_REG_INT1_MASK 0x43
+#define ADM9240_REG_INT2_MASK 0x44
+
+#define ADM9240_REG_COMPAT 0x45        /* dummy compat. register for other drivers? */
+#define ADM9240_REG_CHASSIS_CLEAR 0x46
+#define ADM9240_REG_VID_FAN_DIV 0x47
+#define ADM9240_REG_I2C_ADDR 0x48
+#define ADM9240_REG_VID4 0x49
+#define ADM9240_REG_TEMP_CONFIG 0x4B
+#define ADM9240_REG_EXTMODE1 0x4C      /* LM81 only - not supported */
+#define ADM9240_REG_EXTMODE2 0x4D      /* LM81 only - not supported */
+
+/* Conversions. Rounding and limit checking is only done on the TO_REG
+   variants. Note that you should be a bit careful with which arguments
+   these macros are called: arguments may be evaluated more than once.
+   Fixing this is just not worth it. */
+#define IN_TO_REG(val,nr) (SENSORS_LIMIT((val), 0, 255))
+#define IN_FROM_REG(val,nr) (val)
+
+static inline u8 FAN_TO_REG(long rpm, int div)
+{
+       if (rpm == 0)
+               return 255;
+       rpm = SENSORS_LIMIT(rpm, 1, 1000000);
+       return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1,
+                            254);
+}
+
+#define FAN_FROM_REG(val,div) ((val)==0?-1:\
+                               (val)==255?0:1350000/((div)*(val)))
+
+#define TEMP_FROM_REG(temp) ((temp)<256 ? (temp) * 5 : \
+                             ((temp) - 512) * 5)
+
+#define TEMP_LIMIT_FROM_REG(val) (((val)>=0x80?(val)-0x100:(val))*10)
+
+#define TEMP_LIMIT_TO_REG(val) SENSORS_LIMIT(((val)<0?(((val)-5)/10)+256:\
+                                                      ((val)+5)/10), \
+                                             0,255)
+
+#define ALARMS_FROM_REG(val) (val)
+
+#define DIV_FROM_REG(val) (1 << (val))
+#define DIV_TO_REG(val) ((val)==1?0:((val)==8?3:((val)==4?2:1)))
+
+#define VID_FROM_REG(val) ((val)==0x1f?0:(val)>=0x10?510-(val)*10:\
+                           205-(val)*5)
+
+/* For each registered ADM9240, we need to keep some data in memory. */
+struct adm9240_data {
+       struct i2c_client client;
+       int sysctl_id;
+       enum chips type;
+
+       struct semaphore update_lock;
+       char valid;             /* !=0 if following fields are valid */
+       unsigned long last_updated;     /* In jiffies */
+
+       u8 in[6];               /* Register value */
+       u8 in_max[6];           /* Register value */
+       u8 in_min[6];           /* Register value */
+       u8 fan[2];              /* Register value */
+       u8 fan_min[2];          /* Register value */
+       u8 fan_div[2];          /* Register encoding, shifted right */
+       int temp;               /* Temp, shifted right */
+       u8 temp_os_max;         /* Register value */
+       u8 temp_os_hyst;        /* Register value */
+       u16 alarms;             /* Register encoding, combined */
+       u8 analog_out;          /* Register value */
+       u8 vid;                 /* Register value combined */
+};
+
+
+static int adm9240_attach_adapter(struct i2c_adapter *adapter);
+static int adm9240_detect(struct i2c_adapter *adapter, int address,
+                         unsigned short flags, int kind);
+static int adm9240_detach_client(struct i2c_client *client);
+
+static int adm9240_read_value(struct i2c_client *client, u8 reg);
+static int adm9240_write_value(struct i2c_client *client, u8 reg, u8 value);
+static void adm9240_update_client(struct i2c_client *client);
+static void adm9240_init_client(struct i2c_client *client);
+
+
+static void adm9240_in(struct i2c_client *client, int operation,
+                      int ctl_name, int *nrels_mag, long *results);
+static void adm9240_fan(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void adm9240_temp(struct i2c_client *client, int operation,
+                        int ctl_name, int *nrels_mag, long *results);
+static void adm9240_alarms(struct i2c_client *client, int operation,
+                          int ctl_name, int *nrels_mag, long *results);
+static void adm9240_fan_div(struct i2c_client *client, int operation,
+                           int ctl_name, int *nrels_mag, long *results);
+static void adm9240_analog_out(struct i2c_client *client, int operation,
+                              int ctl_name, int *nrels_mag,
+                              long *results);
+static void adm9240_vid(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+
+static int adm9240_id = 0;
+
+static struct i2c_driver adm9240_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "ADM9240 sensor driver",
+       .id             = I2C_DRIVERID_ADM9240,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = adm9240_attach_adapter,
+       .detach_client  = adm9240_detach_client,
+};
+
+/* The /proc/sys entries */
+
+/* -- SENSORS SYSCTL START -- */
+
+#define ADM9240_SYSCTL_IN0 1000        /* Volts * 100 */
+#define ADM9240_SYSCTL_IN1 1001
+#define ADM9240_SYSCTL_IN2 1002
+#define ADM9240_SYSCTL_IN3 1003
+#define ADM9240_SYSCTL_IN4 1004
+#define ADM9240_SYSCTL_IN5 1005
+#define ADM9240_SYSCTL_FAN1 1101       /* Rotations/min */
+#define ADM9240_SYSCTL_FAN2 1102
+#define ADM9240_SYSCTL_TEMP 1250       /* Degrees Celcius * 100 */
+#define ADM9240_SYSCTL_FAN_DIV 2000    /* 1, 2, 4 or 8 */
+#define ADM9240_SYSCTL_ALARMS 2001     /* bitvector */
+#define ADM9240_SYSCTL_ANALOG_OUT 2002
+#define ADM9240_SYSCTL_VID 2003
+
+#define ADM9240_ALARM_IN0 0x0001
+#define ADM9240_ALARM_IN1 0x0002
+#define ADM9240_ALARM_IN2 0x0004
+#define ADM9240_ALARM_IN3 0x0008
+#define ADM9240_ALARM_IN4 0x0100
+#define ADM9240_ALARM_IN5 0x0200
+#define ADM9240_ALARM_FAN1 0x0040
+#define ADM9240_ALARM_FAN2 0x0080
+#define ADM9240_ALARM_TEMP 0x0010
+#define ADM9240_ALARM_CHAS 0x1000
+
+/* -- SENSORS SYSCTL END -- */
+
+/* These files are created for each detected ADM9240. This is just a template;
+   though at first sight, you might think we could use a statically
+   allocated list, we need some way to get back to the parent - which
+   is done through one of the 'extra' fields which are initialized 
+   when a new copy is allocated. */
+static ctl_table adm9240_dir_table_template[] = {
+       {ADM9240_SYSCTL_IN0, "in0", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm9240_in},
+       {ADM9240_SYSCTL_IN1, "in1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm9240_in},
+       {ADM9240_SYSCTL_IN2, "in2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm9240_in},
+       {ADM9240_SYSCTL_IN3, "in3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm9240_in},
+       {ADM9240_SYSCTL_IN4, "in4", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm9240_in},
+       {ADM9240_SYSCTL_IN5, "in5", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm9240_in},
+       {ADM9240_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm9240_fan},
+       {ADM9240_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm9240_fan},
+       {ADM9240_SYSCTL_TEMP, "temp", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm9240_temp},
+       {ADM9240_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm9240_fan_div},
+       {ADM9240_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm9240_alarms},
+       {ADM9240_SYSCTL_ANALOG_OUT, "analog_out", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm9240_analog_out},
+       {ADM9240_SYSCTL_VID, "vid", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &adm9240_vid},
+       {0}
+};
+
+static int adm9240_attach_adapter(struct i2c_adapter *adapter)
+{
+       return i2c_detect(adapter, &addr_data, adm9240_detect);
+}
+
+static int adm9240_detect(struct i2c_adapter *adapter, int address,
+                         unsigned short flags, int kind)
+{
+       int i;
+       struct i2c_client *new_client;
+       struct adm9240_data *data;
+       int err = 0;
+       const char *type_name = "";
+       const char *client_name = "";
+
+       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
+               goto ERROR0;
+
+       /* OK. For now, we presume we have a valid client. We now create the
+          client structure, even though we cannot fill it completely yet.
+          But it allows us to access adm9240_{read,write}_value. */
+
+       if (!(data = kmalloc(sizeof(struct adm9240_data), GFP_KERNEL))) {
+               err = -ENOMEM;
+               goto ERROR0;
+       }
+
+
+       new_client = &data->client;
+       new_client->addr = address;
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &adm9240_driver;
+       new_client->flags = 0;
+
+       /* Now, we do the remaining detection. */
+
+       if (kind < 0) {
+               if (
+                   ((adm9240_read_value
+                     (new_client, ADM9240_REG_CONFIG) & 0x80) != 0x00)
+                   ||
+                   (adm9240_read_value(new_client, ADM9240_REG_I2C_ADDR)
+                    != address))
+                       goto ERROR1;
+       }
+
+       /* Determine the chip type. */
+       if (kind <= 0) {
+               i = adm9240_read_value(new_client, ADM9240_REG_COMPANY_ID);
+               if (i == 0x23)
+                       kind = adm9240;
+               else if (i == 0xda)
+                       kind = ds1780;
+               else if (i == 0x01)
+                       kind = lm81;
+               else {
+                       if (kind == 0)
+                               printk
+                                   ("adm9240.o: Ignoring 'force' parameter for unknown chip at "
+                                    "adapter %d, address 0x%02x\n",
+                                    i2c_adapter_id(adapter), address);
+                       goto ERROR1;
+               }
+       }
+
+       if (kind == adm9240) {
+               type_name = "adm9240";
+               client_name = "ADM9240 chip";
+       } else if (kind == ds1780) {
+               type_name = "ds1780";
+               client_name = "DS1780 chip";
+       } else if (kind == lm81) {
+               type_name = "lm81";
+               client_name = "LM81 chip";
+       } else {
+#ifdef DEBUG
+               printk("adm9240.o: Internal error: unknown kind (%d)?!?",
+                      kind);
+#endif
+               goto ERROR1;
+       }
+
+       /* Fill in the remaining client fields and put it into the global list */
+       strcpy(new_client->name, client_name);
+       data->type = kind;
+
+       new_client->id = adm9240_id++;
+       data->valid = 0;
+       init_MUTEX(&data->update_lock);
+
+       /* Tell the I2C layer a new client has arrived */
+       if ((err = i2c_attach_client(new_client)))
+               goto ERROR3;
+
+       /* Register a new directory entry with module sensors */
+       if ((i = i2c_register_entry(new_client,
+                                       type_name,
+                                       adm9240_dir_table_template)) < 0) {
+               err = i;
+               goto ERROR4;
+       }
+       data->sysctl_id = i;
+
+       /* Initialize the ADM9240 chip */
+       adm9240_init_client(new_client);
+       return 0;
+
+/* OK, this is not exactly good programming practice, usually. But it is
+   very code-efficient in this case. */
+
+      ERROR4:
+       i2c_detach_client(new_client);
+      ERROR3:
+      ERROR1:
+       kfree(data);
+      ERROR0:
+       return err;
+}
+
+static int adm9240_detach_client(struct i2c_client *client)
+{
+       int err;
+
+       i2c_deregister_entry(((struct adm9240_data *) (client->data))->
+                                sysctl_id);
+
+       if ((err = i2c_detach_client(client))) {
+               printk
+                   ("adm9240.o: Client deregistration failed, client not detached.\n");
+               return err;
+       }
+
+       kfree(client->data);
+
+       return 0;
+}
+
+
+static int adm9240_read_value(struct i2c_client *client, u8 reg)
+{
+       return i2c_smbus_read_byte_data(client, reg);
+}
+
+static int adm9240_write_value(struct i2c_client *client, u8 reg, u8 value)
+{
+       return i2c_smbus_write_byte_data(client, reg, value);
+}
+
+/* Called when we have found a new ADM9240. */
+static void adm9240_init_client(struct i2c_client *client)
+{
+       /* Start monitoring */
+       adm9240_write_value(client, ADM9240_REG_CONFIG, 0x01);
+}
+
+static void adm9240_update_client(struct i2c_client *client)
+{
+       struct adm9240_data *data = client->data;
+       u8 i;
+
+       down(&data->update_lock);
+
+       if (
+           (jiffies - data->last_updated >
+            (data->type == adm9240 ? HZ / 2 : HZ * 2))
+           || (jiffies < data->last_updated) || !data->valid) {
+
+#ifdef DEBUG
+               printk("Starting adm9240 update\n");
+#endif
+               for (i = 0; i <= 5; i++) {
+                       data->in[i] =
+                           adm9240_read_value(client, ADM9240_REG_IN(i));
+                       data->in_min[i] =
+                           adm9240_read_value(client,
+                                              ADM9240_REG_IN_MIN(i));
+                       data->in_max[i] =
+                           adm9240_read_value(client,
+                                              ADM9240_REG_IN_MAX(i));
+               }
+               data->fan[0] =
+                   adm9240_read_value(client, ADM9240_REG_FAN1);
+               data->fan_min[0] =
+                   adm9240_read_value(client, ADM9240_REG_FAN1_MIN);
+               data->fan[1] =
+                   adm9240_read_value(client, ADM9240_REG_FAN2);
+               data->fan_min[1] =
+                   adm9240_read_value(client, ADM9240_REG_FAN2_MIN);
+               data->temp =
+                   (adm9240_read_value(client, ADM9240_REG_TEMP) << 1) +
+                   ((adm9240_read_value
+                     (client, ADM9240_REG_TEMP_CONFIG) & 0x80) >> 7);
+               data->temp_os_max =
+                   adm9240_read_value(client, ADM9240_REG_TOS);
+               data->temp_os_hyst =
+                   adm9240_read_value(client, ADM9240_REG_THYST);
+
+               i = adm9240_read_value(client, ADM9240_REG_VID_FAN_DIV);
+               data->fan_div[0] = (i >> 4) & 0x03;
+               data->fan_div[1] = (i >> 6) & 0x03;
+               data->vid = i & 0x0f;
+               data->vid |=
+                   (adm9240_read_value(client, ADM9240_REG_VID4) & 0x01)
+                   << 4;
+
+               data->alarms =
+                   adm9240_read_value(client,
+                                      ADM9240_REG_INT1_STAT) +
+                   (adm9240_read_value(client, ADM9240_REG_INT2_STAT) <<
+                    8);
+               data->analog_out =
+                   adm9240_read_value(client, ADM9240_REG_ANALOG_OUT);
+               data->last_updated = jiffies;
+               data->valid = 1;
+       }
+
+       up(&data->update_lock);
+}
+
+
+/* The next few functions are the call-back functions of the /proc/sys and
+   sysctl files. Which function is used is defined in the ctl_table in
+   the extra1 field.
+   Each function must return the magnitude (power of 10 to divide the date
+   with) if it is called with operation==SENSORS_PROC_REAL_INFO. It must
+   put a maximum of *nrels elements in results reflecting the data of this
+   file, and set *nrels to the number it actually put in it, if operation==
+   SENSORS_PROC_REAL_READ. Finally, it must get upto *nrels elements from
+   results and write them to the chip, if operations==SENSORS_PROC_REAL_WRITE.
+   Note that on SENSORS_PROC_REAL_READ, I do not check whether results is
+   large enough (by checking the incoming value of *nrels). This is not very
+   good practice, but as long as you put less than about 5 values in results,
+   you can assume it is large enough. */
+void adm9240_in(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+
+       int scales[6] = { 250, 270, 330, 500, 1200, 270 };
+
+       struct adm9240_data *data = client->data;
+       int nr = ctl_name - ADM9240_SYSCTL_IN0;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 2;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm9240_update_client(client);
+               results[0] =
+                   IN_FROM_REG(data->in_min[nr], nr) * scales[nr] / 192;
+               results[1] =
+                   IN_FROM_REG(data->in_max[nr], nr) * scales[nr] / 192;
+               results[2] =
+                   IN_FROM_REG(data->in[nr], nr) * scales[nr] / 192;
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->in_min[nr] =
+                           IN_TO_REG((results[0] * 192) / scales[nr], nr);
+                       adm9240_write_value(client, ADM9240_REG_IN_MIN(nr),
+                                           data->in_min[nr]);
+               }
+               if (*nrels_mag >= 2) {
+                       data->in_max[nr] =
+                           IN_TO_REG((results[1] * 192) / scales[nr], nr);
+                       adm9240_write_value(client, ADM9240_REG_IN_MAX(nr),
+                                           data->in_max[nr]);
+               }
+       }
+}
+
+void adm9240_fan(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct adm9240_data *data = client->data;
+       int nr = ctl_name - ADM9240_SYSCTL_FAN1 + 1;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm9240_update_client(client);
+               results[0] = FAN_FROM_REG(data->fan_min[nr - 1],
+                                         DIV_FROM_REG(data->
+                                                      fan_div[nr - 1]));
+               results[1] =
+                   FAN_FROM_REG(data->fan[nr - 1],
+                                DIV_FROM_REG(data->fan_div[nr - 1]));
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->fan_min[nr - 1] = FAN_TO_REG(results[0],
+                                                          DIV_FROM_REG
+                                                          (data->
+                                                           fan_div[nr -
+                                                                   1]));
+                       adm9240_write_value(client,
+                                           nr ==
+                                           1 ? ADM9240_REG_FAN1_MIN :
+                                           ADM9240_REG_FAN2_MIN,
+                                           data->fan_min[nr - 1]);
+               }
+       }
+}
+
+
+void adm9240_temp(struct i2c_client *client, int operation, int ctl_name,
+                 int *nrels_mag, long *results)
+{
+       struct adm9240_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm9240_update_client(client);
+               results[0] = TEMP_LIMIT_FROM_REG(data->temp_os_max);
+               results[1] = TEMP_LIMIT_FROM_REG(data->temp_os_hyst);
+               results[2] = TEMP_FROM_REG(data->temp);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->temp_os_max = TEMP_LIMIT_TO_REG(results[0]);
+                       adm9240_write_value(client, ADM9240_REG_TOS,
+                                           data->temp_os_max);
+               }
+               if (*nrels_mag >= 2) {
+                       data->temp_os_hyst = TEMP_LIMIT_TO_REG(results[1]);
+                       adm9240_write_value(client, ADM9240_REG_THYST,
+                                           data->temp_os_hyst);
+               }
+       }
+}
+
+void adm9240_alarms(struct i2c_client *client, int operation, int ctl_name,
+                   int *nrels_mag, long *results)
+{
+       struct adm9240_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm9240_update_client(client);
+               results[0] = ALARMS_FROM_REG(data->alarms);
+               *nrels_mag = 1;
+       }
+}
+
+void adm9240_fan_div(struct i2c_client *client, int operation,
+                    int ctl_name, int *nrels_mag, long *results)
+{
+       struct adm9240_data *data = client->data;
+       int old;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm9240_update_client(client);
+               results[0] = DIV_FROM_REG(data->fan_div[0]);
+               results[1] = DIV_FROM_REG(data->fan_div[1]);
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               old = adm9240_read_value(client, ADM9240_REG_VID_FAN_DIV);
+               if (*nrels_mag >= 2) {
+                       data->fan_div[1] = DIV_TO_REG(results[1]);
+                       old = (old & 0x3f) | (data->fan_div[1] << 6);
+               }
+               if (*nrels_mag >= 1) {
+                       data->fan_div[0] = DIV_TO_REG(results[0]);
+                       old = (old & 0xcf) | (data->fan_div[0] << 4);
+                       adm9240_write_value(client,
+                                           ADM9240_REG_VID_FAN_DIV, old);
+               }
+       }
+}
+
+void adm9240_analog_out(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results)
+{
+       struct adm9240_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm9240_update_client(client);
+               results[0] = data->analog_out;
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->analog_out = results[0];
+                       adm9240_write_value(client, ADM9240_REG_ANALOG_OUT,
+                                           data->analog_out);
+               }
+       }
+}
+
+void adm9240_vid(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct adm9240_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 2;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               adm9240_update_client(client);
+               results[0] = VID_FROM_REG(data->vid);
+               *nrels_mag = 1;
+       }
+}
+
+static int __init sm_adm9240_init(void)
+{
+       printk("adm9240.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       return i2c_add_driver(&adm9240_driver);
+}
+
+static void __exit sm_adm9240_exit(void)
+{
+       i2c_del_driver(&adm9240_driver);
+}
+
+
+
+MODULE_AUTHOR
+    ("Frodo Looijaard <frodol@dds.nl> and Philip Edelbrock <phil@netroedge.com>");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("ADM9240 driver");
+
+module_init(sm_adm9240_init);
+module_exit(sm_adm9240_exit);
--- linux-old/drivers/sensors/asb100.c  Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/asb100.c      Mon Dec 13 20:18:45 2004
@@ -0,0 +1,1025 @@
+/*
+    asb100.c - Part of lm_sensors, Linux kernel modules for hardware
+                monitoring
+
+    Copyright (c) 2003 Mark M. Hoffman <mhoffman@lightlink.com>
+
+       (derived from w83781d.c)
+
+    Copyright (c) 1998 - 2003  Frodo Looijaard <frodol@dds.nl>,
+    Philip Edelbrock <phil@netroedge.com>, and
+    Mark Studebaker <mdsxyz123@yahoo.com>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+    This driver supports the hardware sensor chips: Asus ASB100 and
+    ASB100-A "BACH".
+
+    ASB100-A supports pwm1, while plain ASB100 does not.  There is no known
+    way for the driver to tell which one is there.
+
+    Chip       #vin    #fanin  #pwm    #temp   wchipid vendid  i2c     ISA
+    asb100     7       3       1       4       0x31    0x0694  yes     no
+*/
+
+//#define DEBUG 1
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+#include <linux/sensors_vid.h>
+#include "lm75.h"
+
+#ifndef I2C_DRIVERID_ASB100
+#define I2C_DRIVERID_ASB100            1043
+#endif
+
+/* I2C addresses to scan */
+static unsigned short normal_i2c[] = { SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { 0x28, 0x2f, SENSORS_I2C_END };
+
+/* ISA addresses to scan (none) */
+static unsigned int normal_isa[] = { SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+/* default VRM to 9.0 instead of 8.2 */
+#define ASB100_DEFAULT_VRM 90
+
+/* Insmod parameters */
+SENSORS_INSMOD_1(asb100);
+SENSORS_MODULE_PARM(force_subclients, "List of subclient addresses: " \
+       "{bus, clientaddr, subclientaddr1, subclientaddr2}");
+
+/* Voltage IN registers 0-6 */
+#define ASB100_REG_IN(nr)     (0x20 + (nr))
+#define ASB100_REG_IN_MAX(nr) (0x2b + (nr * 2))
+#define ASB100_REG_IN_MIN(nr) (0x2c + (nr * 2))
+
+/* FAN IN registers 1-3 */
+#define ASB100_REG_FAN(nr)     (0x27 + (nr))
+#define ASB100_REG_FAN_MIN(nr) (0x3a + (nr))
+
+/* TEMPERATURE registers 1-4 */
+static const u16 asb100_reg_temp[]     = {0, 0x27, 0x150, 0x250, 0x17};
+static const u16 asb100_reg_temp_max[] = {0, 0x39, 0x155, 0x255, 0x18};
+static const u16 asb100_reg_temp_hyst[]        = {0, 0x3a, 0x153, 0x253, 0x19};
+
+#define ASB100_REG_TEMP(nr) (asb100_reg_temp[nr])
+#define ASB100_REG_TEMP_MAX(nr) (asb100_reg_temp_max[nr])
+#define ASB100_REG_TEMP_HYST(nr) (asb100_reg_temp_hyst[nr])
+
+#define ASB100_REG_TEMP2_CONFIG        0x0152
+#define ASB100_REG_TEMP3_CONFIG        0x0252
+
+
+#define ASB100_REG_CONFIG      0x40
+#define ASB100_REG_ALARM1      0x41
+#define ASB100_REG_ALARM2      0x42
+#define ASB100_REG_SMIM1       0x43
+#define ASB100_REG_SMIM2       0x44
+#define ASB100_REG_VID_FANDIV  0x47
+#define ASB100_REG_I2C_ADDR    0x48
+#define ASB100_REG_CHIPID      0x49
+#define ASB100_REG_I2C_SUBADDR 0x4a
+#define ASB100_REG_PIN         0x4b
+#define ASB100_REG_IRQ         0x4c
+#define ASB100_REG_BANK                0x4e
+#define ASB100_REG_CHIPMAN     0x4f
+
+#define ASB100_REG_WCHIPID     0x58
+
+/* bit 7 -> enable, bits 0-3 -> duty cycle */
+#define ASB100_REG_PWM1                0x59
+
+/* CONVERSIONS
+   Rounding and limit checking is only done on the TO_REG variants. */
+
+/* These constants are a guess, consistent w/ w83781d */
+#define ASB100_IN_MIN (  0)
+#define ASB100_IN_MAX (408)
+
+/* IN: 1/100 V (0V to 4.08V)
+   REG: 16mV/bit */
+static u8 IN_TO_REG(unsigned val)
+{
+       unsigned nval = SENSORS_LIMIT(val, ASB100_IN_MIN, ASB100_IN_MAX);
+       return (nval * 10 + 8) / 16;
+}
+
+static unsigned IN_FROM_REG(u8 reg)
+{
+       return (reg * 16 + 5) / 10;
+}
+
+static u8 FAN_TO_REG(long rpm, int div)
+{
+       if (rpm == 0)
+               return 255;
+       rpm = SENSORS_LIMIT(rpm, 1, 1000000);
+       return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
+}
+
+static int FAN_FROM_REG(u8 val, int div)
+{
+       return val==0 ? -1 : val==255 ? 0 : 1350000/(val*div);
+}
+
+/* These constants are a guess, consistent w/ w83781d */
+#define ASB100_TEMP_MIN (-1280)
+#define ASB100_TEMP_MAX ( 1270)
+
+/* TEMP: 1/10 degrees C (-128C to +127C)
+   REG: 1C/bit, two's complement */
+static u8 TEMP_TO_REG(int temp)
+{
+       int ntemp = SENSORS_LIMIT(temp, ASB100_TEMP_MIN, ASB100_TEMP_MAX);
+       ntemp += (ntemp<0 ? -5 : 5);
+       return (u8)(ntemp / 10);
+}
+
+static int TEMP_FROM_REG(u8 reg)
+{
+       return (s8)reg * 10;
+}
+
+/* PWM: 0 - 255 per sensors documentation
+   REG: (6.25% duty cycle per bit) */
+static u8 ASB100_PWM_TO_REG(int pwm)
+{
+       pwm = SENSORS_LIMIT(pwm, 0, 255);
+       return (u8)(pwm / 16);
+}
+
+static int ASB100_PWM_FROM_REG(u8 reg)
+{
+       return reg * 16;
+}
+
+#define ALARMS_FROM_REG(val) (val)
+
+#define DIV_FROM_REG(val) (1 << (val))
+
+/* FAN DIV: 1, 2, 4, or 8 (defaults to 2)
+   REG: 0, 1, 2, or 3 (respectively) (defaults to 1) */
+static u8 DIV_TO_REG(long val)
+{
+       return val==8 ? 3 : val==4 ? 2 : val==1 ? 0 : 1;
+}
+
+/* For each registered client, we need to keep some data in memory. That
+   data is pointed to by client->data. The structure itself is
+   dynamically allocated, at the same time the client itself is allocated. */
+struct asb100_data {
+       struct i2c_client client;
+       struct semaphore lock;
+       int sysctl_id;
+       enum chips type;
+
+       struct semaphore update_lock;
+       unsigned long last_updated;     /* In jiffies */
+
+       /* array of 2 pointers to subclients */
+       struct i2c_client *lm75[2];
+
+       char valid;             /* !=0 if following fields are valid */
+       u8 in[7];               /* Register value */
+       u8 in_max[7];           /* Register value */
+       u8 in_min[7];           /* Register value */
+       u8 fan[3];              /* Register value */
+       u8 fan_min[3];          /* Register value */
+       u16 temp[4];            /* Register value (0 and 3 are u8 only) */
+       u16 temp_max[4];        /* Register value (0 and 3 are u8 only) */
+       u16 temp_hyst[4];       /* Register value (0 and 3 are u8 only) */
+       u8 fan_div[3];          /* Register encoding, right justified */
+       u8 pwm;                 /* Register encoding */
+       u8 vid;                 /* Register encoding, combined */
+       u32 alarms;             /* Register encoding, combined */
+       u8 vrm;
+};
+
+static int asb100_attach_adapter(struct i2c_adapter *adapter);
+static int asb100_detect(struct i2c_adapter *adapter, int address,
+               unsigned short flags, int kind);
+static int asb100_detach_client(struct i2c_client *client);
+
+static int asb100_read_value(struct i2c_client *client, u16 reg);
+static void asb100_write_value(struct i2c_client *client, u16 reg, u16 val);
+static void asb100_update_client(struct i2c_client *client);
+static void asb100_init_client(struct i2c_client *client);
+
+static void asb100_in(struct i2c_client *client, int operation,
+               int ctl_name, int *nrels_mag, long *results);
+static void asb100_fan(struct i2c_client *client, int operation,
+               int ctl_name, int *nrels_mag, long *results);
+static void asb100_temp(struct i2c_client *client, int operation,
+               int ctl_name, int *nrels_mag, long *results);
+static void asb100_temp_add(struct i2c_client *client, int operation,
+               int ctl_name, int *nrels_mag, long *results);
+static void asb100_vid(struct i2c_client *client, int operation,
+               int ctl_name, int *nrels_mag, long *results);
+static void asb100_vrm(struct i2c_client *client, int operation,
+               int ctl_name, int *nrels_mag, long *results);
+static void asb100_alarms(struct i2c_client *client, int operation,
+               int ctl_name, int *nrels_mag, long *results);
+static void asb100_fan_div(struct i2c_client *client, int operation,
+               int ctl_name, int *nrels_mag, long *results);
+static void asb100_pwm(struct i2c_client *client, int operation,
+               int ctl_name, int *nrels_mag, long *results);
+
+static struct i2c_driver asb100_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "asb100",
+       .id             = I2C_DRIVERID_ASB100,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = asb100_attach_adapter,
+       .detach_client  = asb100_detach_client,
+};
+
+/* The /proc/sys entries */
+/* -- SENSORS SYSCTL START -- */
+
+#define ASB100_SYSCTL_IN0      1000    /* Volts * 100 */
+#define ASB100_SYSCTL_IN1      1001
+#define ASB100_SYSCTL_IN2      1002
+#define ASB100_SYSCTL_IN3      1003
+#define ASB100_SYSCTL_IN4      1004
+#define ASB100_SYSCTL_IN5      1005
+#define ASB100_SYSCTL_IN6      1006
+
+#define ASB100_SYSCTL_FAN1     1101    /* Rotations/min */
+#define ASB100_SYSCTL_FAN2     1102
+#define ASB100_SYSCTL_FAN3     1103
+
+#define ASB100_SYSCTL_TEMP1    1200    /* Degrees Celcius * 10 */
+#define ASB100_SYSCTL_TEMP2    1201
+#define ASB100_SYSCTL_TEMP3    1202
+#define ASB100_SYSCTL_TEMP4    1203
+
+#define ASB100_SYSCTL_VID      1300    /* Volts * 1000 */
+#define ASB100_SYSCTL_VRM      1301
+
+#define ASB100_SYSCTL_PWM1     1401    /* 0-255 => 0-100% duty cycle */
+
+#define ASB100_SYSCTL_FAN_DIV  2000    /* 1, 2, 4 or 8 */
+#define ASB100_SYSCTL_ALARMS   2001    /* bitvector */
+
+#define ASB100_ALARM_IN0       0x0001  /* ? */
+#define ASB100_ALARM_IN1       0x0002  /* ? */
+#define ASB100_ALARM_IN2       0x0004
+#define ASB100_ALARM_IN3       0x0008
+#define ASB100_ALARM_TEMP1     0x0010
+#define ASB100_ALARM_TEMP2     0x0020
+#define ASB100_ALARM_FAN1      0x0040
+#define ASB100_ALARM_FAN2      0x0080
+#define ASB100_ALARM_IN4       0x0100
+#define ASB100_ALARM_IN5       0x0200  /* ? */
+#define ASB100_ALARM_IN6       0x0400  /* ? */
+#define ASB100_ALARM_FAN3      0x0800
+#define ASB100_ALARM_CHAS      0x1000
+#define ASB100_ALARM_TEMP3     0x2000
+
+#define ASB100_ALARM_IN7       0x10000 /* ? */
+#define ASB100_ALARM_IN8       0x20000 /* ? */
+
+/* -- SENSORS SYSCTL END -- */
+
+/* These files are created for each detected chip. This is just a template;
+   though at first sight, you might think we could use a statically
+   allocated list, we need some way to get back to the parent - which
+   is done through one of the 'extra' fields which are initialized 
+   when a new copy is allocated. */
+
+/* no datasheet - but we did get some hints from someone who 
+   claimed to have the datasheet */
+#define ASB100_SYSCTL_IN(nr) {ASB100_SYSCTL_IN##nr, "in" #nr, NULL, 0, \
+       0644, NULL, &i2c_proc_real, &i2c_sysctl_real, NULL, &asb100_in}
+#define ASB100_SYSCTL_FAN(nr) {ASB100_SYSCTL_FAN##nr, "fan" #nr, NULL, 0, \
+       0644, NULL, &i2c_proc_real, &i2c_sysctl_real, NULL, &asb100_fan}
+#define ASB100_SYSCTL_TEMP(nr, func) {ASB100_SYSCTL_TEMP##nr, "temp" #nr, \
+       NULL, 0, 0644, NULL, &i2c_proc_real, &i2c_sysctl_real, NULL, func}
+static ctl_table asb100_dir_table_template[] = {
+       ASB100_SYSCTL_IN(0),
+       ASB100_SYSCTL_IN(1),
+       ASB100_SYSCTL_IN(2),
+       ASB100_SYSCTL_IN(3),
+       ASB100_SYSCTL_IN(4),
+       ASB100_SYSCTL_IN(5),
+       ASB100_SYSCTL_IN(6),
+
+       ASB100_SYSCTL_FAN(1),
+       ASB100_SYSCTL_FAN(2),
+       ASB100_SYSCTL_FAN(3),
+
+       ASB100_SYSCTL_TEMP(1, &asb100_temp),
+       ASB100_SYSCTL_TEMP(2, &asb100_temp_add),
+       ASB100_SYSCTL_TEMP(3, &asb100_temp_add),
+       ASB100_SYSCTL_TEMP(4, &asb100_temp),
+
+       {ASB100_SYSCTL_VID, "vid", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &asb100_vid},
+       {ASB100_SYSCTL_VRM, "vrm", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &asb100_vrm},
+       {ASB100_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &asb100_fan_div},
+       {ASB100_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &asb100_alarms},
+       {ASB100_SYSCTL_PWM1, "pwm1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &asb100_pwm},
+       {0}
+};
+
+/* This function is called when:
+       asb100_driver is inserted (when this module is loaded), for each
+               available adapter
+       when a new adapter is inserted (and asb100_driver is still present)
+ */
+static int asb100_attach_adapter(struct i2c_adapter *adapter)
+{
+       return i2c_detect(adapter, &addr_data, asb100_detect);
+}
+
+static int asb100_detect_subclients(struct i2c_adapter *adapter, int address,
+               int kind, struct i2c_client *new_client)
+{
+       int i, id, err;
+       struct asb100_data *data = new_client->data;
+
+       data->lm75[0] = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
+       if (!(data->lm75[0])) {
+               err = -ENOMEM;
+               goto ERROR_SC_0;
+       }
+       memset(data->lm75[0], 0x00, sizeof(struct i2c_client));
+
+       data->lm75[1] = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
+       if (!(data->lm75[1])) {
+               err = -ENOMEM;
+               goto ERROR_SC_1;
+       }
+       memset(data->lm75[1], 0x00, sizeof(struct i2c_client));
+
+       id = i2c_adapter_id(adapter);
+
+       if (force_subclients[0] == id && force_subclients[1] == address) {
+               for (i = 2; i <= 3; i++) {
+                       if (force_subclients[i] < 0x48 ||
+                               force_subclients[i] > 0x4f) {
+                               printk(KERN_ERR "asb100.o: invalid subclient "
+                                       "address %d; must be 0x48-0x4f\n",
+                                       force_subclients[i]);
+                               err = -ENODEV;
+                               goto ERROR_SC_2;
+                       }
+               }
+               asb100_write_value(new_client, ASB100_REG_I2C_SUBADDR,
+                                   (force_subclients[2] & 0x07) |
+                                   ((force_subclients[3] & 0x07) <<4));
+               data->lm75[0]->addr = force_subclients[2];
+               data->lm75[1]->addr = force_subclients[3];
+       } else {
+               int val = asb100_read_value(new_client, ASB100_REG_I2C_SUBADDR);
+               data->lm75[0]->addr = 0x48 + (val & 0x07);
+               data->lm75[1]->addr = 0x48 + ((val >> 4) & 0x07);
+       }
+
+       if(data->lm75[0]->addr == data->lm75[1]->addr) {
+               printk(KERN_ERR "asb100.o: duplicate addresses 0x%x "
+                               "for subclients\n", data->lm75[0]->addr);
+               err = -ENODEV;
+               goto ERROR_SC_2;
+       }
+
+       for (i = 0; i <= 1; i++) {
+               data->lm75[i]->data = NULL;
+               data->lm75[i]->adapter = adapter;
+               data->lm75[i]->driver = &asb100_driver;
+               data->lm75[i]->flags = 0;
+               strcpy(data->lm75[i]->name, "asb100 subclient");
+       }
+
+       if ((err = i2c_attach_client(data->lm75[0]))) {
+               printk(KERN_ERR "asb100.o: Subclient %d registration "
+                       "at address 0x%x failed.\n", i, data->lm75[0]->addr);
+               goto ERROR_SC_2;
+       }
+
+       if ((err = i2c_attach_client(data->lm75[1]))) {
+               printk(KERN_ERR "asb100.o: Subclient %d registration "
+                       "at address 0x%x failed.\n", i, data->lm75[1]->addr);
+               goto ERROR_SC_3;
+       }
+
+       return 0;
+
+/* Undo inits in case of errors */
+ERROR_SC_3:
+       i2c_detach_client(data->lm75[0]);
+ERROR_SC_2:
+       kfree(data->lm75[1]);
+ERROR_SC_1:
+       kfree(data->lm75[0]);
+ERROR_SC_0:
+       return err;
+}
+
+static int asb100_detect(struct i2c_adapter *adapter, int address,
+               unsigned short flags, int kind)
+{
+       int err;
+       struct i2c_client *new_client;
+       struct asb100_data *data;
+
+       /* asb100 is SMBus only */
+       if (i2c_is_isa_adapter(adapter)) {
+               pr_debug("asb100.o: detect failed, "
+                               "cannot attach to legacy adapter!\n");
+               err = -ENODEV;
+               goto ERROR0;
+       }
+
+       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
+               pr_debug("asb100.o: detect failed, "
+                               "smbus byte data not supported!\n");
+               err = -ENODEV;
+               goto ERROR0;
+       }
+
+       /* OK. For now, we presume we have a valid client. We now create the
+          client structure, even though we cannot fill it completely yet.
+          But it allows us to access asb100_{read,write}_value. */
+
+       if (!(data = kmalloc(sizeof(struct asb100_data), GFP_KERNEL))) {
+               pr_debug("asb100.o: detect failed, kmalloc failed!\n");
+               err = -ENOMEM;
+               goto ERROR0;
+       }
+
+       new_client = &data->client;
+       new_client->addr = address;
+       init_MUTEX(&data->lock);
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &asb100_driver;
+       new_client->flags = 0;
+
+       /* Now, we do the remaining detection. */
+
+       /* The chip may be stuck in some other bank than bank 0. This may
+          make reading other information impossible. Specify a force=... or
+          force_*=... parameter, and the chip will be reset to the right
+          bank. */
+       if (kind < 0) {
+
+               int val1 = asb100_read_value(new_client, ASB100_REG_BANK);
+               int val2 = asb100_read_value(new_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);
+                       err = -ENODEV;
+                       goto ERROR1;
+               }
+
+       } /* kind < 0 */
+
+       /* We have either had a force parameter, or we have already detected
+          Winbond. Put it now into bank 0 and Vendor ID High Byte */
+       asb100_write_value(new_client, ASB100_REG_BANK,
+               (asb100_read_value(new_client, ASB100_REG_BANK) & 0x78) | 0x80);
+
+       /* Determine the chip type. */
+       if (kind <= 0) {
+               int val1 = asb100_read_value(new_client, ASB100_REG_WCHIPID);
+               int val2 = asb100_read_value(new_client, ASB100_REG_CHIPMAN);
+
+               if ((val1 == 0x31) && (val2 == 0x06))
+                       kind = asb100;
+               else {
+                       if (kind == 0)
+                               printk (KERN_WARNING "asb100.o: Ignoring "
+                                       "'force' parameter for unknown chip "
+                                       "at adapter %d, address 0x%02x.\n",
+                                       i2c_adapter_id(adapter), address);
+                       err = -ENODEV;
+                       goto ERROR1;
+               }
+       }
+
+       /* Fill in remaining client fields and put it into the global list */
+       strcpy(new_client->name, "ASB100 chip");
+       data->type = kind;
+
+       data->valid = 0;
+       init_MUTEX(&data->update_lock);
+
+       /* Tell the I2C layer a new client has arrived */
+       if ((err = i2c_attach_client(new_client)))
+               goto ERROR1;
+
+       /* Attach secondary lm75 clients */
+       if ((err = asb100_detect_subclients(adapter, address, kind,
+                       new_client)))
+               goto ERROR2;
+
+       /* Initialize the chip */
+       asb100_init_client(new_client);
+
+       /* Register a new directory entry with module sensors */
+       if ((data->sysctl_id = i2c_register_entry(new_client, "asb100",
+                       asb100_dir_table_template)) < 0) {
+               err = data->sysctl_id;
+               goto ERROR3;
+       }
+
+       return 0;
+
+ERROR3:
+       i2c_detach_client(data->lm75[0]);
+       kfree(data->lm75[1]);
+       kfree(data->lm75[0]);
+ERROR2:
+       i2c_detach_client(new_client);
+ERROR1:
+       kfree(data);
+ERROR0:
+       return err;
+}
+
+static int asb100_detach_client(struct i2c_client *client)
+{
+       int err;
+       struct asb100_data *data = client->data;
+
+       /* remove sysctl table (primary client only) */
+       if ((data))
+               i2c_deregister_entry(data->sysctl_id);
+
+       if ((err = i2c_detach_client(client))) {
+               printk (KERN_ERR "asb100.o: Client deregistration failed; "
+                       "client not detached.\n");
+               return err;
+       }
+
+       if (data) {
+               /* primary client */
+               kfree(data);
+       } else {
+               /* subclients */
+               kfree(client);
+       }
+
+       return 0;
+}
+
+/* The SMBus locks itself, usually, but nothing may access the Winbond between
+   bank switches. ISA access must always be locked explicitly! 
+   We ignore the W83781D BUSY flag at this moment - it could lead to deadlocks,
+   would slow down the W83781D access and should not be necessary. 
+   There are some ugly typecasts here, but the good news is - they should
+   nowhere else be necessary! */
+static int asb100_read_value(struct i2c_client *client, u16 reg)
+{
+       struct asb100_data *data = client->data;
+       struct i2c_client *cl;
+       int res, bank;
+
+       down(&data->lock);
+
+       bank = (reg >> 8) & 0x0f;
+       if (bank > 2)
+               /* switch banks */
+               i2c_smbus_write_byte_data(client, ASB100_REG_BANK, bank);
+
+       if (bank == 0 || bank > 2) {
+               res = i2c_smbus_read_byte_data(client, reg & 0xff);
+       } else {
+               /* switch to subclient */
+               cl = data->lm75[bank - 1];
+
+               /* convert from ISA to LM75 I2C addresses */
+               switch (reg & 0xff) {
+               case 0x50: /* TEMP */
+                       res = swab16(i2c_smbus_read_word_data (cl, 0));
+                       break;
+               case 0x52: /* CONFIG */
+                       res = i2c_smbus_read_byte_data(cl, 1);
+                       break;
+               case 0x53: /* HYST */
+                       res = swab16(i2c_smbus_read_word_data (cl, 2));
+                       break;
+               case 0x55: /* MAX */
+               default:
+                       res = swab16(i2c_smbus_read_word_data (cl, 3));
+                       break;
+               }
+       }
+
+       if (bank > 2)
+               i2c_smbus_write_byte_data(client, ASB100_REG_BANK, 0);
+
+       up(&data->lock);
+
+       return res;
+}
+
+static void asb100_write_value(struct i2c_client *client, u16 reg, u16 value)
+{
+       struct asb100_data *data = client->data;
+       struct i2c_client *cl;
+       int bank;
+
+       down(&data->lock);
+
+       bank = (reg >> 8) & 0x0f;
+       if (bank > 2)
+               /* switch banks */
+               i2c_smbus_write_byte_data(client, ASB100_REG_BANK, bank);
+
+       if (bank == 0 || bank > 2) {
+               i2c_smbus_write_byte_data(client, reg & 0xff, value & 0xff);
+       } else {
+               /* switch to subclient */
+               cl = data->lm75[bank - 1];
+
+               /* convert from ISA to LM75 I2C addresses */
+               switch (reg & 0xff) {
+               case 0x52: /* CONFIG */
+                       i2c_smbus_write_byte_data(cl, 1, value & 0xff);
+                       break;
+               case 0x53: /* HYST */
+                       i2c_smbus_write_word_data(cl, 2, swab16(value));
+                       break;
+               case 0x55: /* MAX */
+                       i2c_smbus_write_word_data(cl, 3, swab16(value));
+                       break;
+               }
+       }
+
+       if (bank > 2)
+               i2c_smbus_write_byte_data(client, ASB100_REG_BANK, 0);
+
+       up(&data->lock);
+}
+
+static void asb100_init_client(struct i2c_client *client)
+{
+       struct asb100_data *data = client->data;
+       int vid = 0;
+
+       vid = asb100_read_value(client, ASB100_REG_VID_FANDIV) & 0x0f;
+       vid |= (asb100_read_value(client, ASB100_REG_CHIPID) & 0x01) << 4;
+       data->vrm = ASB100_DEFAULT_VRM;
+       vid = vid_from_reg(vid, data->vrm);
+
+       /* Start monitoring */
+       asb100_write_value(client, ASB100_REG_CONFIG, 
+               (asb100_read_value(client, ASB100_REG_CONFIG) & 0xf7) | 0x01);
+}
+
+static void asb100_update_client(struct i2c_client *client)
+{
+       struct asb100_data *data = client->data;
+       int i;
+
+       down(&data->update_lock);
+
+       if (time_after(jiffies - data->last_updated, HZ + HZ / 2) ||
+               time_before(jiffies, data->last_updated) || !data->valid) {
+
+               pr_debug("asb100.o: starting device update...\n");
+
+               /* 7 voltage inputs */
+               for (i = 0; i < 7; i++) {
+                       data->in[i] = asb100_read_value(client,
+                               ASB100_REG_IN(i));
+                       data->in_min[i] = asb100_read_value(client,
+                               ASB100_REG_IN_MIN(i));
+                       data->in_max[i] = asb100_read_value(client,
+                               ASB100_REG_IN_MAX(i));
+               }
+
+               /* 3 fan inputs */
+               for (i = 1; i <= 3; i++) {
+                       data->fan[i-1] = asb100_read_value(client,
+                                       ASB100_REG_FAN(i));
+                       data->fan_min[i-1] = asb100_read_value(client,
+                                       ASB100_REG_FAN_MIN(i));
+               }
+
+               /* 4 temperature inputs */
+               for (i = 1; i <= 4; i++) {
+                       data->temp[i-1] = asb100_read_value(client,
+                                       ASB100_REG_TEMP(i));
+                       data->temp_max[i-1] = asb100_read_value(client,
+                                       ASB100_REG_TEMP_MAX(i));
+                       data->temp_hyst[i-1] = asb100_read_value(client,
+                                       ASB100_REG_TEMP_HYST(i));
+               }
+
+               /* VID and fan divisors */
+               i = asb100_read_value(client, ASB100_REG_VID_FANDIV);
+               data->vid = i & 0x0f;
+               data->vid |= (asb100_read_value(client,
+                               ASB100_REG_CHIPID) & 0x01) << 4;
+               data->fan_div[0] = (i >> 4) & 0x03;
+               data->fan_div[1] = (i >> 6) & 0x03;
+               data->fan_div[2] = (asb100_read_value(client,
+                               ASB100_REG_PIN) >> 6) & 0x03;
+
+               /* PWM */
+               data->pwm = asb100_read_value(client, ASB100_REG_PWM1);
+
+               /* alarms */
+               data->alarms = asb100_read_value(client, ASB100_REG_ALARM1) +
+                       (asb100_read_value(client, ASB100_REG_ALARM2) << 8);
+
+               data->last_updated = jiffies;
+               data->valid = 1;
+
+               pr_debug("asb100.o: ... update complete.\n");
+       }
+
+       up(&data->update_lock);
+}
+
+
+/* The next few functions are the call-back functions of the /proc/sys and
+   sysctl files. Which function is used is defined in the ctl_table in
+   the extra1 field.
+   Each function must return the magnitude (power of 10 to divide the date
+   with) if it is called with operation==SENSORS_PROC_REAL_INFO. It must
+   put a maximum of *nrels elements in results reflecting the data of this
+   file, and set *nrels to the number it actually put in it, if operation==
+   SENSORS_PROC_REAL_READ. Finally, it must get upto *nrels elements from
+   results and write them to the chip, if operations==SENSORS_PROC_REAL_WRITE.
+   Note that on SENSORS_PROC_REAL_READ, I do not check whether results is
+   large enough (by checking the incoming value of *nrels). This is not very
+   good practice, but as long as you put less than about 5 values in results,
+   you can assume it is large enough. */
+static void asb100_in(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       struct asb100_data *data = client->data;
+       int nr = ctl_name - ASB100_SYSCTL_IN0;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 2;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               asb100_update_client(client);
+               results[0] = IN_FROM_REG(data->in_min[nr]);
+               results[1] = IN_FROM_REG(data->in_max[nr]);
+               results[2] = IN_FROM_REG(data->in[nr]);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->in_min[nr] = IN_TO_REG(results[0]);
+                       asb100_write_value(client, ASB100_REG_IN_MIN(nr),
+                                           data->in_min[nr]);
+               }
+               if (*nrels_mag >= 2) {
+                       data->in_max[nr] = IN_TO_REG(results[1]);
+                       asb100_write_value(client, ASB100_REG_IN_MAX(nr),
+                                           data->in_max[nr]);
+               }
+       }
+}
+
+void asb100_fan(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct asb100_data *data = client->data;
+       int nr = ctl_name - ASB100_SYSCTL_FAN1 + 1;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               asb100_update_client(client);
+               results[0] = FAN_FROM_REG(data->fan_min[nr - 1],
+                                 DIV_FROM_REG(data->fan_div[nr - 1]));
+               results[1] = FAN_FROM_REG(data->fan[nr - 1],
+                                 DIV_FROM_REG(data->fan_div[nr - 1]));
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->fan_min[nr - 1] =
+                            FAN_TO_REG(results[0],
+                                   DIV_FROM_REG(data->fan_div[nr-1]));
+                       asb100_write_value(client,
+                                           ASB100_REG_FAN_MIN(nr),
+                                           data->fan_min[nr - 1]);
+               }
+       }
+}
+
+void asb100_temp(struct i2c_client *client, int operation, int ctl_name,
+                 int *nrels_mag, long *results)
+{
+       struct asb100_data *data = client->data;
+       int nr = ctl_name - ASB100_SYSCTL_TEMP1;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               asb100_update_client(client);
+               results[0] = TEMP_FROM_REG(data->temp_max[nr]);
+               results[1] = TEMP_FROM_REG(data->temp_hyst[nr]);
+               results[2] = TEMP_FROM_REG(data->temp[nr]);
+               *nrels_mag = 3;
+
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->temp_max[nr] = TEMP_TO_REG(results[0]);
+                       asb100_write_value(client, ASB100_REG_TEMP_MAX(nr+1),
+                               data->temp_max[nr]);
+               }
+               if (*nrels_mag >= 2) {
+                       data->temp_hyst[nr] = TEMP_TO_REG(results[1]);
+                       asb100_write_value(client, ASB100_REG_TEMP_HYST(nr+1),
+                               data->temp_hyst[nr]);
+               }
+       }
+}
+
+void asb100_temp_add(struct i2c_client *client, int operation,
+                     int ctl_name, int *nrels_mag, long *results)
+{
+       struct asb100_data *data = client->data;
+       int nr = ctl_name - ASB100_SYSCTL_TEMP1;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               asb100_update_client(client);
+
+               results[0] = LM75_TEMP_FROM_REG(data->temp_max[nr]);
+               results[1] = LM75_TEMP_FROM_REG(data->temp_hyst[nr]);
+               results[2] = LM75_TEMP_FROM_REG(data->temp[nr]);
+               *nrels_mag = 3;
+
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->temp_max[nr] =
+                               LM75_TEMP_TO_REG(results[0]);
+                       asb100_write_value(client, ASB100_REG_TEMP_MAX(nr+1),
+                               data->temp_max[nr]);
+               }
+               if (*nrels_mag >= 2) {
+                       data->temp_hyst[nr] =
+                               LM75_TEMP_TO_REG(results[1]);
+                       asb100_write_value(client, ASB100_REG_TEMP_HYST(nr+1),
+                               data->temp_hyst[nr]);
+               }
+       }
+}
+
+void asb100_vid(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct asb100_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 3;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               asb100_update_client(client);
+               results[0] = vid_from_reg(data->vid, data->vrm);
+               *nrels_mag = 1;
+       }
+}
+
+void asb100_vrm(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct asb100_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               results[0] = data->vrm;
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1)
+                       data->vrm = results[0];
+       }
+}
+
+void asb100_alarms(struct i2c_client *client, int operation, int ctl_name,
+                   int *nrels_mag, long *results)
+{
+       struct asb100_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               asb100_update_client(client);
+               results[0] = ALARMS_FROM_REG(data->alarms);
+               *nrels_mag = 1;
+       }
+}
+
+void asb100_fan_div(struct i2c_client *client, int operation,
+                    int ctl_name, int *nrels_mag, long *results)
+{
+       struct asb100_data *data = client->data;
+       int old, old2;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               asb100_update_client(client);
+               results[0] = DIV_FROM_REG(data->fan_div[0]);
+               results[1] = DIV_FROM_REG(data->fan_div[1]);
+               results[2] = DIV_FROM_REG(data->fan_div[2]);
+               *nrels_mag = 3;
+
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               old = asb100_read_value(client, ASB100_REG_VID_FANDIV);
+               if (*nrels_mag >= 3) {
+                       data->fan_div[2] = DIV_TO_REG(results[2]);
+                       old2 = asb100_read_value(client, ASB100_REG_PIN);
+                       old2 = (old2 & 0x3f) | ((data->fan_div[2] & 0x03) << 6);
+                       asb100_write_value(client, ASB100_REG_PIN, old2);
+               }
+               if (*nrels_mag >= 2) {
+                       data->fan_div[1] = DIV_TO_REG(results[1]);
+                       old = (old & 0x3f) | ((data->fan_div[1] & 0x03) << 6);
+               }
+               if (*nrels_mag >= 1) {
+                       data->fan_div[0] = DIV_TO_REG(results[0]);
+                       old = (old & 0xcf) | ((data->fan_div[0] & 0x03) << 4);
+                       asb100_write_value(client, ASB100_REG_VID_FANDIV, old);
+               }
+       }
+}
+
+void asb100_pwm(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       struct asb100_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               asb100_update_client(client);
+               results[0] = ASB100_PWM_FROM_REG(data->pwm & 0x0f);
+               results[1] = (data->pwm & 0x80) ? 1 : 0;
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               u8 val = data->pwm;
+               if (*nrels_mag >= 1) {
+                       val = 0x0f & ASB100_PWM_TO_REG(results[0]);
+                       if (*nrels_mag >= 2) {
+                               if (results[1])
+                                       val |= 0x80;
+                               else
+                                       val &= ~0x80;
+                       }
+                       asb100_write_value(client, ASB100_REG_PWM1, val);
+               }
+       }
+}
+
+static int __init asb100_init(void)
+{
+       printk(KERN_INFO "asb100.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       return i2c_add_driver(&asb100_driver);
+}
+
+static void __exit asb100_exit(void)
+{
+       i2c_del_driver(&asb100_driver);
+}
+
+MODULE_AUTHOR( "Mark M. Hoffman <mhoffman@lightlink.com>, "
+               "Frodo Looijaard <frodol@dds.nl>, "
+               "Philip Edelbrock <phil@netroedge.com>, and"
+               "Mark Studebaker <mdsxyz123@yahoo.com>");
+
+MODULE_DESCRIPTION("ASB100 'Bach' driver");
+MODULE_LICENSE("GPL");
+
+module_init(asb100_init);
+module_exit(asb100_exit);
+
--- linux-old/drivers/sensors/bt869.c   Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/bt869.c       Mon Dec 13 20:18:45 2004
@@ -0,0 +1,891 @@
+/*
+    bt869.c - Part of lm_sensors, Linux kernel modules for hardware
+             monitoring
+
+    Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl>
+    Copyright (c) 2001, 2002  Stephen Davies  <steve@daviesfam.org>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+
+#define DEBUG 1
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+MODULE_LICENSE("GPL");
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = { SENSORS_I2C_END };
+
+/* found only at 0x44 or 0x45 */
+static unsigned short normal_i2c_range[] = { 0x44, 0x45, SENSORS_I2C_END };
+static unsigned int normal_isa[] = { SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+/* Insmod parameters */
+SENSORS_INSMOD_1(bt869);
+
+/* Many bt869 constants specified below */
+
+/* The bt869 registers */
+/* Coming soon: Many, many registers */
+
+/* Conversions. Rounding and limit checking is only done on the TO_REG
+   variants. Note that you should be a bit careful with which arguments
+   these macros are called: arguments may be evaluated more than once.
+   Fixing this is just not worth it. */
+
+   /*none */
+
+/* Initial values */
+/*none*/
+
+/* Each client has this additional data */
+struct bt869_data {
+       struct i2c_client client;
+       int sysctl_id;
+
+       struct semaphore update_lock;
+       char valid;             /* !=0 if following fields are valid */
+       unsigned long last_updated;     /* In jiffies */
+
+       u8 status[3];           /* Register values */
+       u16 res[2];             /* Resolution XxY */
+       u8 ntsc;                /* 1=NTSC, 0=PAL */
+       u8 half;                /* go half res */
+       u8 depth;               /* screen depth */
+       u8 colorbars;           /* turn on/off colorbar calibration screen */
+        u8 svideo;              /* output format: (2=RGB) 1=SVIDEO, 0=Composite */
+};
+
+static int bt869_attach_adapter(struct i2c_adapter *adapter);
+static int bt869_detect(struct i2c_adapter *adapter, int address,
+                       unsigned short flags, int kind);
+static void bt869_init_client(struct i2c_client *client);
+static int bt869_detach_client(struct i2c_client *client);
+static int bt869_read_value(struct i2c_client *client, u8 reg);
+static int bt869_write_value(struct i2c_client *client, u8 reg, u16 value);
+static void bt869_write_values(struct i2c_client *client, u16 *values);
+static void bt869_status(struct i2c_client *client, int operation,
+                        int ctl_name, int *nrels_mag, long *results);
+static void bt869_ntsc(struct i2c_client *client, int operation,
+                      int ctl_name, int *nrels_mag, long *results);
+static void bt869_res(struct i2c_client *client, int operation,
+                     int ctl_name, int *nrels_mag, long *results);
+static void bt869_half(struct i2c_client *client, int operation,
+                      int ctl_name, int *nrels_mag, long *results);
+static void bt869_colorbars(struct i2c_client *client, int operation,
+                           int ctl_name, int *nrels_mag, long *results);
+static void bt869_svideo(struct i2c_client *client, int operation,
+                           int ctl_name, int *nrels_mag, long *results);
+static void bt869_depth(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void bt869_update_client(struct i2c_client *client);
+
+
+/* This is the driver that will be inserted */
+static struct i2c_driver bt869_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "BT869 video-output chip driver",
+       .id             = I2C_DRIVERID_BT869,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = bt869_attach_adapter,
+       .detach_client  = bt869_detach_client,
+};
+
+/* -- SENSORS SYSCTL START -- */
+#define BT869_SYSCTL_STATUS 1000
+#define BT869_SYSCTL_NTSC   1001
+#define BT869_SYSCTL_HALF   1002
+#define BT869_SYSCTL_RES    1003
+#define BT869_SYSCTL_COLORBARS    1004
+#define BT869_SYSCTL_DEPTH  1005
+#define BT869_SYSCTL_SVIDEO 1006
+
+/* -- SENSORS SYSCTL END -- */
+
+/* These files are created for each detected bt869. This is just a template;
+   though at first sight, you might think we could use a statically
+   allocated list, we need some way to get back to the parent - which
+   is done through one of the 'extra' fields which are initialized
+   when a new copy is allocated. */
+static ctl_table bt869_dir_table_template[] = {
+       {BT869_SYSCTL_STATUS, "status", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &bt869_status},
+       {BT869_SYSCTL_NTSC, "ntsc", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &bt869_ntsc},
+       {BT869_SYSCTL_RES, "res", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &bt869_res},
+       {BT869_SYSCTL_HALF, "half", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &bt869_half},
+       {BT869_SYSCTL_COLORBARS, "colorbars", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &bt869_colorbars},
+       {BT869_SYSCTL_DEPTH, "depth", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &bt869_depth},
+       {BT869_SYSCTL_SVIDEO, "svideo", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &bt869_svideo},
+       {0}
+};
+
+/* ******************
+
+720x576, 27.5MHz, PAL, no overscan compensation.
+
+This mode should be use for digital video, DVD playback etc.
+
+NOTE: This mode for PAL, see 720x480 for an equivalent NTSC mode
+NOTE:    -- Steve Davies <steve@daviesfam.org>
+
+
+Compatible X modeline:
+
+    Mode        "720x576-BT869"
+        DotClock        27.5
+        HTimings        720 744 800 880
+        VTimings        576 581 583 625
+    EndMode
+
+
+625LINE=1                                                      625 line output format
+BST_AMP[7:0]=x57 87                                            Burst ampl. multiplication factor (PAL std??)
+BY_PLL=0                                                       Use the PLL
+CATTENUATE[2:0]=0                                              No chroma attenuation
+CCF1B1[7:0]=0                                                  close caption stuff
+CCF1B2[7:0]=0                                                  close caption stuff
+CCF2B1[7:0]=0                                                  close caption stuff
+CCF2B2[7:0]=0                                                  close caption stuff
+CCORING[2:0]=0                                                 Bypass chroma coring
+CCR_START[8:0]=0 [CCR_START[8]=0; CCR_START[7:0]=0]            Close-caption clock runin start from hsync
+CC_ADD[11:0]=xD2 210  [CC_ADD[11:8]=0; CC_ADD[7:0]=xD2]                Close-caption DTO increment
+CHECK_STAT=0                                                   Don't check monitor status
+CLPF[1:0]=0                                                    Hoz chroma lowpass filter=Bypass
+DACDISA=1                                                      Disable DACA
+DACDISB=0                                                      Don't disable DACB
+DACDISC=0                                                      Don't disable DACC
+DACOFF=0                                                       Don't disable the DACs
+DATDLY = 0                                                     normal
+DATSWP=0                                                       normal
+DCHROMA=0                                                      Don't blank chroma
+DIS_FFILT=1                                                    Disable flickerfilter
+DIS_GMSHC=1                                                    Disable chroma psuedo-gamma removal
+DIS_GMSHY=1                                                    Disable luma pseudo gamma removal
+DIS_GMUSHC=1                                                   Disable chroma anti-pseudo gamma removal
+DIS_GMUSHY=1                                                   Disable luma anti-pseudo gamma removal
+DIS_SCRESET=0                                                  Normal subcarrier phase resets
+DIS_YFLPF=0                                                    Disable Luma initial hoz low pass filter
+DIV2=0                                                         Input pixel rate not divided by 2
+ECBAR=0                                                                No colour bars
+ECCF1=0                                                                Disable closed caption
+ECCF2=0                                                                Disable closed caption
+ECCGATE=0                                                      Normal close caption encoding
+ECLIP=0                                                                0=disable clipping
+EN_ASYNC=0                                                     set to 0 for normal operation
+EN_BLANKO=0                                                    BLANK is an input
+EN_DOT=0                                                       Disables dot clock sync on BLANK pin
+EN_OUT=1                                                       Allows outputs to be enabled
+EN_XCLK=1                                                      Use CLKI pin as clock source
+ESTATUS[1:0]=0                                                 Used to select readback register
+FIELDI=0                                                       Logical 1 on FIELD indicates even field
+F_SELC[2:0]=0                                                  5 line chroma flickerfilter
+F_SELY[2:0]=0                                                  5 line luma flickerfilter
+HBURST_BEGIN[7:0]=x98 152                                      Chroma burst start point in clocks
+HBURST_END[7:0]=x58 88                                         Chroma burst end point in clocks - 128
+HSYNCI=0                                                       Active low HSYNC
+HSYNC_WIDTH[7:0]=x80 128                                       Analogue sync width in clocks
+HSYNOFFSET[9:0]=0  [HSYNOFFSET[9:8]=0; HSYNOFFSET[7:0]=0]      hsync in "standard position"
+HSYNWIDTH[5:0]=2                                               2 pixel hsync width
+H_ACTIVE[9:0]=x2D0 720  [H_ACTIVE[9:8]=2; H_ACTIVE[7:0]=xD0]   Active pixels per line
+H_BLANKI[8:0]=x84 132  [H_BLANKI[8]=0; H_BLANKI[7:0]=x84]      End of blanking of input video
+H_BLANKO[9:0]=x120 288  [H_BLANKO[9:8]=1; H_BLANKO[7:0]=x20]   End of blanking from hoz sync leading edge
+H_CLKI[10:0]=x378 888  [H_CLKI[10:8]=3; H_CLKI[7:0]=x78]       Input line length total in clocks
+H_CLKO[11:0]=x6e0 1760  [H_CLKO[11:8]=6; H_CLKO[7:0]=xe0]      Output clocks per line
+H_FRACT[7:0]=0                                                 0 fractional input clocks per line
+IN_MODE[2:0]=0                                                 24Bit RGB muxed
+LUMADLY[1:0]=0                                                 0 pixel delay on Y_DLY luma
+MCB[7:0]=x49 73                                                        Mult factor for CB prior to subcarrier mod.
+MCR[7:0]=x82 130                                               Mult factor for CR prior to subcarrier mod.
+MODE2X=0                                                       Don't divide clock input by 2
+MSC[31:0]=x2945E0B4 692445365  [MSC[31:24]=x29; MSC[23:16]=x45; MSC[15:8]=xE0; MSC[7:0]=xB4] Subcarrier incr.
+MY[7:0]=x8C 140                                                        Mult factor for Y
+NI_OUT=0                                                       Normal interlaced output
+OUT_MODE[1:0]=0                                                        video0-3 is CVBS, Y, C, Y_DLY
+OUT_MUXA[1:0]=0                                                        Don't care as DACA is disabled
+OUT_MUXB[1:0]=1                                                        Output video[1] (Y) on DACB
+OUT_MUXC[1:0]=2                                                        Output video[2] (C) on DACC
+PAL_MD=1                                                       Video output in PAL mode
+PHASE_OFF[7:0]=0                                               Subcarrier phase offset
+PLL_FRACT[15:0]=x30 48  [PLL_FRACT[15:8]=0x0; PLL_FRACT[7:0]=x30] frac portion of pll multiplier
+PLL_INT[5:0]=0x0C 12                                           Int portion of pll multiplier
+SETUP=0                                                                7.5-IRE setup disabled
+SLAVER=1                                                       
+SRESET=0                                                       Don't do a software reset
+SYNC_AMP[7:0]=xF0 240                                          Sync amp mult. factor (PAL std???)
+VBLANKDLY=0                                                    Extra line of blanking in 2nd field?
+VSYNCI=0                                                       Active low VSYNC
+VSYNC_DUR=0                                                    2.5line VSYNC duration on output
+VSYNCOFFSET[10:0]=0  [VSYNOFFSET[10:8]=0; VSYNOFFSET[7:0]=0]   VSYNC in standard position
+VSYNWIDTH[2:0]=1                                               1 line of vsync width
+V_ACTIVEI[9:0]=x240 576  [V_ACTIVEI[9:0]=2; V_ACTIVEI[7:0]=x40]        Active input lines
+V_ACTIVEO[8:0]=x122 290  [V_ACTIVE0[8]=1; V_ACTIVEO[7:0]=x22]
+V_BLANKI[7:0]=x2A 42                                           Input lines from vsync to first active line
+V_BLANKO[7:0]=x16 22
+V_LINESI[9:0]=x271 625  [V_LINESI[9:8]=2; V_LINESI[7:0]=x71]   Number of input lines
+V_SCALE[13:0]=x1000 4096  [V_SCALE[13:8]=x10; V_SCALE[7:0]=0]  Vert scale coefficient="none"?
+YATTENUATE[2:0]=0                                              no luma attenuation
+YCORING[2:0]=0                                                 Luma-coring bypass
+YLPF[1:0]=0                                                    Luma hoz low pass filter=bypass
+
+***************** */
+
+static u16 registers_720_576[] =
+    {
+      0x6e, 0x00,      /* HSYNOFFSET[7:0]=0 */
+      0x70, 0x02,      /* HSYNOFFSET[9:8]=0; HSYNWIDTH[5:0]=2 */
+      0x72, 0x00,      /* VSYNOFFSET[7:0]=0 */
+      0x74, 0x01,      /* DATDLY = 0; DATSWP=0; VSYNOFFSET[10:8]=0; VSYNWIDTH[2:0]=1 */
+      0x76, 0xe0,      /* H_CLKO[7:0]=xe0 */
+      0x78, 0xd0,      /* H_ACTIVE[7:0]=xD0 */
+      0x7a, 0x80,      /* HSYNC_WIDTH[7:0]=x80 */
+      0x7c, 0x98,      /* HBURST_BEGIN[7:0]=x98 */
+      0x7e, 0x58,      /* HBURST_END[7:0]=x58 */
+      0x80, 0x20,      /* H_BLANKO[7:0]=x20 */
+      0x82, 0x16,      /* V_BLANKO[7:0]=x16 */
+      0x84, 0x22,      /* V_ACTIVEO[7:0]=x22 */
+      0x86, 0xa6,      /* V_ACTIVE0[8]=1; H_ACTIVE[9:8]=2; H_CLKO[11:8]=6 */
+      0x88, 0x00,      /* H_FRACT[7:0]=0 */
+      0x8a, 0x78,      /* H_CLKI[7:0]=x78 */
+      0x8c, 0x80,      /* H_BLANKI[7:0]=x84 */
+      0x8e, 0x03,      /* VBLANKDLY=0; H_BLANKI[8]=0; H_CLKI[10:8]=3 */
+      0x90, 0x71,      /* V_LINESI[7:0]=x71 */
+      0x92, 0x2a,      /* V_BLANKI[7:0]=x2A */
+      0x94, 0x40,      /* V_ACTIVEI[7:0]=x40 */
+      0x96, 0x0a,      /* CLPF[1:0]=0; YLPF[1:0]=0; V_ACTIVEI[9:0]=2; V_LINESI[9:8]=2 */
+      0x98, 0x00,      /* V_SCALE[7:0]=0 */
+      0x9a, 0x50,      /* H_BLANKO[9:8]=1; V_SCALE[13:8]=x10 */
+      0x9c, 0x30,      /* PLL_FRACT[7:0]=x30 */
+      0x9e, 0x0,       /* PLL_FRACT[15:8]=0x0 */
+      0xa0, 0x8c,      /* EN_XCLK=1; BY_PLL=0; PLL_INT[5:0]=0x0C */
+      0xa2, 0x24,      /* ECLIP=0; PAL_MD=1; DIS_SCRESET=0; VSYNC_DUR=0; 625LINE=1; SETUP=0; NI_OUT=0 */
+      0xa4, 0xf0,      /* SYNC_AMP[7:0]=xF0 */
+      0xa6, 0x57,      /* BST_AMP[7:0]=x57 */
+      0xa8, 0x82,      /* MCR[7:0]=x82 */
+      0xaa, 0x49,      /* MCB[7:0]=x49 */
+      0xac, 0x8c,      /* MY[7:0]=x8C */
+      0xae, 0xb4,      /* MSC[7:0]=xb4 */
+      0xb0, 0xe0,      /* MSC[15:8]=xe0 */
+      0xb2, 0x45,      /* MSC[23:16]=x45 */
+      0xb4, 0x29,      /* MSC[31:24]=x29 */
+      0xb6, 0x00,      /* PHASE_OFF[7:0]=0 */
+      //0xba, 0x21,    /* SRESET=0; CHECK_STAT=0; SLAVER=1; DACOFF=0; DACDISC=0; DACDISB=0; DACDISA=1 */
+      0xc4, 0x01,      /* ESTATUS[1:0]=0; ECCF2=0; ECCF1=0; ECCGATE=0; ECBAR=0; DCHROMA=0; EN_OUT=1 */
+      0xc6, 0x00,      /* EN_BLANKO=0; EN_DOT=0; FIELDI=0; VSYNCI=0; HSYNCI=0; IN_MODE[2:0]=0(24bRGB) */
+      0xc8, 0x40,      /* DIS_YFLPF=0; DIS_FFILT=1; F_SELC[2:0]=0; F_SELY[2:0]=0 */
+      0xca, 0xc0,      /* DIS_GMUSHY=1; DIS_GMSHY=1; YCORING[2:0]=0; YATTENUATE[2:0]=0 */
+      0xcc, 0xc0,      /* DIS_GMUSHC=1; DIS_GMSHC=1; CCORING[2:0]=0; CATTENUATE[2:0]=0 */
+      //0xce, 0x24,       /* OUT_MUXC=2 [C]; OUT_MUXB=1 [Y]; OUT_MUXA=0 [CVBS, but disabled]*/
+      //0xce, 0x04,       /* OUT_MUXC=0 [CVBS]; OUT_MUXB=1 [Y]; OUT_MUXA=0 [CVBS, but disabled]*/
+      0xd6, 0x00,      /* OUT_MODE[1:0]=0; LUMADLY[1:0]=0 */
+      0, 0
+    };
+
+
+/* ******************
+
+720x480, 27.5MHz, NTSC no overscan compensation.
+
+This mode should be use for digital video, DVD playback etc.
+
+NOTE: This mode for NTSC, see 720x576 for an equivalent PAL mode
+NOTE:    -- Steve Davies <steve@daviesfam.org>
+
+Compatible X modeline:
+
+    Mode        "720x480-BT869"
+        DotClock        27.5
+        HTimings        720 744 800 872
+        VTimings        480 483 485 525
+    EndMode
+
+
+625LINE=0                                                      not 625 line output format
+BST_AMP[7:0]=x74 116                                           Burst ampl. multiplication factor (NTSC std??)
+BY_PLL=0                                                       Use the PLL
+CATTENUATE[2:0]=0                                              No chroma attenuation
+CCF1B1[7:0]=0                                                  close caption stuff
+CCF1B2[7:0]=0                                                  close caption stuff
+CCF2B1[7:0]=0                                                  close caption stuff
+CCF2B2[7:0]=0                                                  close caption stuff
+CCORING[2:0]=0                                                 Bypass chroma coring
+CCR_START[8:0]=0 [CCR_START[8]=0; CCR_START[7:0]=0]            Close-caption clock runin start from hsync
+CC_ADD[11:0]=xD2 210  [CC_ADD[11:8]=0; CC_ADD[7:0]=xD2]                Close-caption DTO increment
+CHECK_STAT=0                                                   Don't check monitor status
+CLPF[1:0]=0                                                    Hoz chroma lowpass filter=Bypass
+DACDISA=1                                                      Disable DACA
+DACDISB=0                                                      Don't disable DACB
+DACDISC=0                                                      Don't disable DACC
+DACOFF=0                                                       Don't disable the DACs
+DATDLY = 0                                                     normal
+DATSWP=0                                                       normal
+DCHROMA=0                                                      Don't blank chroma
+DIS_FFILT=1                                                    Disable flickerfilter
+DIS_GMSHC=1                                                    Disable chroma psuedo-gamma removal
+DIS_GMSHY=1                                                    Disable luma pseudo gamma removal
+DIS_GMUSHC=1                                                   Disable chroma anti-pseudo gamma removal
+DIS_GMUSHY=1                                                   Disable luma anti-pseudo gamma removal
+DIS_SCRESET=0                                                  Normal subcarrier phase resets
+DIS_YFLPF=0                                                    Disable Luma initial hoz low pass filter
+DIV2=0                                                         Input pixel rate not divided by 2
+ECBAR=0                                                                No colour bars
+ECCF1=0                                                                Disable closed caption
+ECCF2=0                                                                Disable closed caption
+ECCGATE=0                                                      Normal close caption encoding
+ECLIP=0                                                                0=disable clipping
+EN_ASYNC=0                                                     set to 0 for normal operation
+EN_BLANKO=0                                                    BLANK is an input
+EN_DOT=0                                                       Disables dot clock sync on BLANK pin
+EN_OUT=1                                                       Allows outputs to be enabled
+EN_XCLK=1                                                      Use CLKI pin as clock source
+ESTATUS[1:0]=0                                                 Used to select readback register
+FIELDI=0                                                       Logical 1 on FIELD indicates even field
+F_SELC[2:0]=0                                                  5 line chroma flickerfilter
+F_SELY[2:0]=0                                                  5 line luma flickerfilter
+HBURST_BEGIN[7:0]=x92 146                                      Chroma burst start point in clocks
+HBURST_END[7:0]=x57 87                                         Chroma burst end point in clocks - 128
+HSYNCI=0                                                       Active low HSYNC
+HSYNC_WIDTH[7:0]=x80 128                                       Analogue sync width in clocks
+HSYNOFFSET[9:0]=0  [HSYNOFFSET[9:8]=0; HSYNOFFSET[7:0]=0]      hsync in "standard position"
+HSYNWIDTH[5:0]=2                                               2 pixel hsync width
+H_ACTIVE[9:0]=x2D0 720  [H_ACTIVE[9:8]=2; H_ACTIVE[7:0]=xD0]   Active pixels per line
+H_BLANKI[8:0]=x80 128  [H_BLANKI[8]=0; H_BLANKI[7:0]=x80]      End of blanking of input video
+H_BLANKO[9:0]=x102 258  [H_BLANKO[9:8]=1; H_BLANKO[7:0]=x2]    End of blanking from hoz sync leading edge
+H_CLKI[10:0]=x368 872  [H_CLKI[10:8]=3; H_CLKI[7:0]=x68]       Input line length total in clocks
+H_CLKO[11:0]=x6d0 1744  [H_CLKO[11:8]=6; H_CLKO[7:0]=xD0]      Output clocks per line
+H_FRACT[7:0]=0                                                 0 fractional input clocks per line
+IN_MODE[2:0]=0                                                 24Bit RGB muxed
+LUMADLY[1:0]=0                                                 0 pixel delay on Y_DLY luma
+MCB[7:0]=x43 67                                                        Mult factor for CB prior to subcarrier mod.
+MCR[7:0]=x77 119                                               Mult factor for CR prior to subcarrier mod.
+MODE2X=0                                                       Don't divide clock input by 2
+MSC[31:0]=x215282E5 559055589  [MSC[31:24]=x21; MSC[23:16]=x52; MSC[15:8]=x82; MSC[7:0]=xE5] Subcarrier incr.
+MY[7:0]=x85 133                                                        Mult factor for Y
+NI_OUT=0                                                       Normal interlaced output
+OUT_MODE[1:0]=0                                                        video0-3 is CVBS, Y, C, Y_DLY
+OUT_MUXA[1:0]=0                                                        Don't care as DACA is disabled
+OUT_MUXB[1:0]=1                                                        Output video[1] (Y) on DACB
+OUT_MUXC[1:0]=2                                                        Output video[2] (C) on DACC
+PAL_MD=0                                                       Video output in PAL mode? No.
+PHASE_OFF[7:0]=0                                               Subcarrier phase offset
+PLL_FRACT[15:0]=x30 48  [PLL_FRACT[15:8]=0x0; PLL_FRACT[7:0]=x30] frac portion of pll multiplier
+PLL_INT[5:0]=0x0C 12                                           Int portion of pll multiplier
+SETUP=1                                                                7.5-IRE enabled for NTSC
+SLAVER=1                                                       
+SRESET=0                                                       Don't do a software reset
+SYNC_AMP[7:0]=xE5 229                                          Sync amp mult. factor (PAL std???)
+VBLANKDLY=0                                                    Extra line of blanking in 2nd field?
+VSYNCI=0                                                       Active low VSYNC
+VSYNC_DUR=1                                                    2.5line VSYNC duration on output (Yes for NTSC)
+VSYNCOFFSET[10:0]=0  [VSYNOFFSET[10:8]=0; VSYNOFFSET[7:0]=0]   VSYNC in standard position
+VSYNWIDTH[2:0]=1                                               1 line of vsync width
+V_ACTIVEI[9:0]=x1E0 480  [V_ACTIVEI[9:0]=1; V_ACTIVEI[7:0]=xE0]        Active input lines
+V_ACTIVEO[8:0]=xF0 240  [V_ACTIVE0[8]=0; V_ACTIVEO[7:0]=xF0]
+V_BLANKI[7:0]=x2A 42                                           Input lines from vsync to first active line
+V_BLANKO[7:0]=x16 22
+V_LINESI[9:0]=x20D 525  [V_LINESI[9:8]=2; V_LINESI[7:0]=x0D]   Number of input lines
+V_SCALE[13:0]=x1000 4096  [V_SCALE[13:8]=x10; V_SCALE[7:0]=0]  Vert scale coefficient="none"?
+YATTENUATE[2:0]=0                                              no luma attenuation
+YCORING[2:0]=0                                                 Luma-coring bypass
+YLPF[1:0]=0                                                    Luma hoz low pass filter=bypass
+
+***************** */
+
+static u16 registers_720_480[] =
+    {
+      0x6e, 0x00,      /* HSYNOFFSET[7:0]=0 */
+      0x70, 0x02,      /* HSYNOFFSET[9:8]=0; HSYNWIDTH[5:0]=2 */
+      0x72, 0x00,      /* VSYNOFFSET[7:0]=0 */
+      0x74, 0x01,      /* DATDLY = 0; DATSWP=0; VSYNOFFSET[10:8]=0; VSYNWIDTH[2:0]=1 */
+      0x76, 0xD0,      /* H_CLKO[7:0]=xD0 */
+      0x78, 0xD0,      /* H_ACTIVE[7:0]=xD0 */
+      0x7a, 0x80,      /* HSYNC_WIDTH[7:0]=x80 */
+      0x7c, 0x92,      /* HBURST_BEGIN[7:0]=x92 */
+      0x7e, 0x57,      /* HBURST_END[7:0]=x57 */
+      0x80, 0x02,      /* H_BLANKO[7:0]=x2 */
+      0x82, 0x16,      /* V_BLANKO[7:0]=x16 */
+      0x84, 0xF0,      /* V_ACTIVEO[7:0]=xF0 */
+      0x86, 0x26,      /* V_ACTIVE0[8]=0; H_ACTIVE[9:8]=2; H_CLKO[11:8]=6 */
+      0x88, 0x00,      /* H_FRACT[7:0]=0 */
+      0x8a, 0xD0,      /* H_CLKI[7:0]=xD0 */
+      0x8c, 0x80,      /* H_BLANKI[7:0]=x80 */
+      0x8e, 0x03,      /* VBLANKDLY=0; H_BLANKI[8]=0; H_CLKI[10:8]=3 */
+      0x90, 0x0D,      /* V_LINESI[7:0]=x0D */
+      0x92, 0x2A,      /* V_BLANKI[7:0]=x2A */
+      0x94, 0xE0,      /* V_ACTIVEI[7:0]=xE0 */
+      0x96, 0x06,      /* CLPF[1:0]=0; YLPF[1:0]=0; V_ACTIVEI[9:8]=1; V_LINESI[9:8]=2 */
+      0x98, 0x00,      /* V_SCALE[7:0]=0 */
+      0x9a, 0x50,      /* H_BLANKO[9:8]=1; V_SCALE[13:8]=x10 */
+      0x9c, 0x30,      /* PLL_FRACT[7:0]=x30 */
+      0x9e, 0x0,       /* PLL_FRACT[15:8]=0x0 */
+      0xa0, 0x8c,      /* EN_XCLK=1; BY_PLL=0; PLL_INT[5:0]=0x0C */
+      0xa2, 0x0A,      /* ECLIP=0; PAL_MD=0; DIS_SCRESET=0; VSYNC_DUR=1; 625LINE=0; SETUP=1; NI_OUT=0 */
+      0xa4, 0xE5,      /* SYNC_AMP[7:0]=xE5 */
+      0xa6, 0x74,      /* BST_AMP[7:0]=x74 */
+      0xa8, 0x77,      /* MCR[7:0]=x77 */
+      0xaa, 0x43,      /* MCB[7:0]=x43 */
+      0xac, 0x85,      /* MY[7:0]=x85 */
+      0xae, 0xE5,      /* MSC[7:0]=xE5 */
+      0xb0, 0x82,      /* MSC[15:8]=x82 */
+      0xb2, 0x52,      /* MSC[23:16]=x52 */
+      0xb4, 0x21,      /* MSC[31:24]=x21 */
+      0xb6, 0x00,      /* PHASE_OFF[7:0]=0 */
+      //0xba, 0x21,    /* SRESET=0; CHECK_STAT=0; SLAVER=1; DACOFF=0; DACDISC=0; DACDISB=0; DACDISA=1 */
+      0xc4, 0x01,      /* ESTATUS[1:0]=0; ECCF2=0; ECCF1=0; ECCGATE=0; ECBAR=0; DCHROMA=0; EN_OUT=1 */
+      0xc6, 0x00,      /* EN_BLANKO=0; EN_DOT=0; FIELDI=0; VSYNCI=0; HSYNCI=0; IN_MODE[2:0]=0(24bRGB) */
+      0xc8, 0x40,      /* DIS_YFLPF=0; DIS_FFILT=1; F_SELC[2:0]=0; F_SELY[2:0]=0 */
+      0xca, 0xc0,      /* DIS_GMUSHY=1; DIS_GMSHY=1; YCORING[2:0]=0; YATTENUATE[2:0]=0 */
+      0xcc, 0xc0,      /* DIS_GMUSHC=1; DIS_GMSHC=1; CCORING[2:0]=0; CATTENUATE[2:0]=0 */
+      //0xce, 0x24,       /* OUT_MUXC=2 [C]; OUT_MUXB=1 [Y]; OUT_MUXA=0 [CVBS, but disabled]*/
+      //0xce, 0x04,       /* OUT_MUXC=0 [CVBS]; OUT_MUXB=1 [Y]; OUT_MUXA=0 [CVBS, but disabled]*/
+      0xd6, 0x00,      /* OUT_MODE[1:0]=0; LUMADLY[1:0]=0 */
+      0, 0
+    };
+
+
+int bt869_id = 0;
+
+static int bt869_attach_adapter(struct i2c_adapter *adapter)
+{
+       return i2c_detect(adapter, &addr_data, bt869_detect);
+}
+
+/* This function is called by i2c_detect */
+int bt869_detect(struct i2c_adapter *adapter, int address,
+                unsigned short flags, int kind)
+{
+       int i, cur;
+       struct i2c_client *new_client;
+       struct bt869_data *data;
+       int err = 0;
+       const char *type_name, *client_name;
+
+
+       printk("bt869.o:  probing address %d .\n", address);
+       /* Make sure we aren't probing the ISA bus!! This is just a safety check
+          at this moment; i2c_detect really won't call us. */
+#ifdef DEBUG
+       if (i2c_is_isa_adapter(adapter)) {
+               printk
+                   ("bt869.o: bt869_detect called for an ISA bus adapter?!?\n");
+               return 0;
+       }
+#endif
+
+       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_READ_BYTE |
+                                    I2C_FUNC_SMBUS_WRITE_BYTE_DATA))
+                   goto ERROR0;
+
+       /* OK. For now, we presume we have a valid client. We now create the
+          client structure, even though we cannot fill it completely yet.
+          But it allows us to access bt869_{read,write}_value. */
+       if (!(data = kmalloc(sizeof(struct bt869_data), GFP_KERNEL))) {
+               err = -ENOMEM;
+               goto ERROR0;
+       }
+
+       new_client = &data->client;
+       new_client->addr = address;
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &bt869_driver;
+       new_client->flags = 0;
+
+       /* Now, we do the remaining detection. It is lousy. */
+       i2c_smbus_write_byte_data(new_client, 0xC4, 0); /* set status bank 0 */
+       cur = i2c_smbus_read_byte(new_client);
+       printk("bt869.o: address 0x%X testing-->0x%X\n", address, cur);
+       if ((cur & 0xE0) != 0x20)
+               goto ERROR1;
+
+       /* Determine the chip type */
+       kind = ((cur & 0x20) >> 5);
+
+       if (kind) {
+               type_name = "bt869";
+               client_name = "bt869 chip";
+               printk("bt869.o: BT869 detected\n");
+       } else {
+               type_name = "bt868";
+               client_name = "bt868 chip";
+               printk("bt869.o: BT868 detected\n");
+       }
+
+       /* Fill in the remaining client fields and put it into the global list */
+       strcpy(new_client->name, client_name);
+
+       new_client->id = bt869_id++;
+       data->valid = 0;
+       init_MUTEX(&data->update_lock);
+
+       /* Tell the I2C layer a new client has arrived */
+       if ((err = i2c_attach_client(new_client)))
+               goto ERROR3;
+
+       /* Register a new directory entry with module sensors */
+       if ((i = i2c_register_entry(new_client, type_name,
+                                       bt869_dir_table_template)) < 0) {
+               err = i;
+               goto ERROR4;
+       }
+       data->sysctl_id = i;
+
+       bt869_init_client((struct i2c_client *) new_client);
+       return 0;
+
+/* OK, this is not exactly good programming practice, usually. But it is
+   very code-efficient in this case. */
+
+      ERROR4:
+       i2c_detach_client(new_client);
+      ERROR3:
+      ERROR1:
+       kfree(data);
+      ERROR0:
+       return err;
+}
+
+static int bt869_detach_client(struct i2c_client *client)
+{
+       int err;
+
+       i2c_deregister_entry(((struct bt869_data *) (client->data))->
+                                sysctl_id);
+
+       if ((err = i2c_detach_client(client))) {
+               printk
+                   ("bt869.o: Client deregistration failed, client not detached.\n");
+               return err;
+       }
+
+       kfree(client->data);
+
+       return 0;
+}
+
+
+/* All registers are byte-sized.
+   bt869 uses a high-byte first convention, which is exactly opposite to
+   the usual practice. */
+static int bt869_read_value(struct i2c_client *client, u8 reg)
+{
+       return i2c_smbus_read_byte(client);
+}
+
+/* All registers are byte-sized.
+   bt869 uses a high-byte first convention, which is exactly opposite to
+   the usual practice. */
+static int bt869_write_value(struct i2c_client *client, u8 reg, u16 value)
+{
+#ifdef DEBUG
+        printk("bt869.o: write_value(0x%X, 0x%X)\n", reg, value);
+#endif
+       return i2c_smbus_write_byte_data(client, reg, value);
+}
+
+static void bt869_write_values(struct i2c_client *client, u16 *values)
+{
+  /* writes set of registers from array.  0,0 marks end of table */
+  while (*values) {
+    bt869_write_value(client, values[0], values[1]);
+    values += 2;
+  }
+}
+
+static void bt869_init_client(struct i2c_client *client)
+{
+       struct bt869_data *data = client->data;
+
+       /* Initialize the bt869 chip */
+       bt869_write_value(client, 0x0ba, 0x80);
+       //   bt869_write_value(client,0x0D6, 0x00);
+       /* Be a slave to the clock on the Voodoo3 */
+       bt869_write_value(client, 0xa0, 0x80);
+       bt869_write_value(client, 0xba, 0x20);
+       /* depth =16bpp */
+       bt869_write_value(client, 0x0C6, 0x001);
+       bt869_write_value(client, 0xC4, 1);
+       /* Flicker free enable and config */
+       bt869_write_value(client, 0xC8, 0);
+       data->res[0] = 640;
+       data->res[1] = 480;
+       data->ntsc = 1;
+       data->half = 0;
+       data->colorbars = 0;
+       data->svideo = 0;
+       data->depth = 16;
+
+}
+
+static void bt869_update_client(struct i2c_client *client)
+{
+       struct bt869_data *data = client->data;
+
+       down(&data->update_lock);
+
+       if ((jiffies - data->last_updated > HZ + HZ / 2) ||
+           (jiffies < data->last_updated) || !data->valid) {
+#ifdef DEBUG
+               printk("Starting bt869 update\n");
+#endif
+               if ((data->res[0] == 800) && (data->res[1] == 600)) {
+                       /* 800x600 built-in mode */
+                       bt869_write_value(client, 0xB8,
+                                         (2 + (!data->ntsc)));
+                       bt869_write_value(client, 0xa0, 0x80 + 0x11);
+                       printk("bt869.o: writing into config -->0x%X\n",
+                              (2 + (!data->ntsc)));
+               }
+               else if ((data->res[0] == 720) && (data->res[1] == 576)) {
+                       /* 720x576 no-overscan-compensation mode suitable for PAL DVD playback */
+                       data->ntsc = 0; /* This mode always PAL */
+                       bt869_write_values(client,  registers_720_576);
+               }
+               else if ((data->res[0] == 720) && (data->res[1] == 480)) {
+                       /* 720x480 no-overscan-compensation mode suitable for NTSC DVD playback */
+                       data->ntsc = 1; /* This mode always NTSC */
+                       bt869_write_values(client,  registers_720_480);
+               }
+               else {
+                       /* 640x480 built-in mode */
+                       bt869_write_value(client, 0xB8, (!data->ntsc));
+                       bt869_write_value(client, 0xa0, 0x80 + 0x0C);
+                       printk("bt869.o: writing into config -->0x%X\n",
+                              (0 + (!data->ntsc)));
+                       if ((data->res[0] != 640) || (data->res[1] != 480)) {
+                         printk
+                           ("bt869.o:  Warning: arbitrary resolutions not supported yet.  Using 640x480.\n");
+                         data->res[0] = 640;
+                         data->res[1] = 480;
+                       }
+               }
+               /* Set colour depth */
+               if ((data->depth != 24) && (data->depth != 16))
+                       data->depth = 16;
+               if (data->depth == 16)
+                       bt869_write_value(client, 0x0C6, 0x001);
+               if (data->depth == 24)
+                       bt869_write_value(client, 0x0C6, 0x000);
+               /* set "half" resolution mode */
+               bt869_write_value(client, 0xd4, data->half << 6);
+               /* Set composite/svideo mode, also enable the right dacs */
+               switch (data->svideo) {
+               case 2:  /* RGB */
+                 /* requires hardware mod on Voodoo3 to get all outputs,
+                    untested in practice... Feedback to steve@daviesfam.org please */
+                 bt869_write_value(client, 0xd6, 0x0c);
+                 bt869_write_value(client, 0xce, 0x24);
+                 bt869_write_value(client, 0xba, 0x20);
+                 break;
+               case 1:  /* Svideo*/
+                 bt869_write_value(client, 0xce, 0x24);
+                 bt869_write_value(client, 0xba, 0x21);
+                 break;
+               default:  /* Composite */
+                 bt869_write_value(client, 0xce, 0x0);
+                 bt869_write_value(client, 0xba, 0x21);
+                 break;
+               }
+               /* Enable outputs */
+               bt869_write_value(client, 0xC4, 1);
+               /* Issue timing reset */
+               bt869_write_value(client, 0x6c, 0x80);
+
+/* Read back status registers */
+               bt869_write_value(client, 0xC4,
+                                 1 | (data->colorbars << 2));
+               data->status[0] = bt869_read_value(client, 1);
+               bt869_write_value(client, 0xC4,
+                                 0x41 | (data->colorbars << 2));
+               data->status[1] = bt869_read_value(client, 1);
+               bt869_write_value(client, 0xC4,
+                                 0x81 | (data->colorbars << 2));
+               data->status[2] = bt869_read_value(client, 1);
+               bt869_write_value(client, 0xC4,
+                                 0x0C1 | (data->colorbars << 2));
+               data->last_updated = jiffies;
+               data->valid = 1;
+       }
+       up(&data->update_lock);
+}
+
+
+void bt869_status(struct i2c_client *client, int operation, int ctl_name,
+                 int *nrels_mag, long *results)
+{
+       struct bt869_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               bt869_update_client(client);
+               results[0] = data->status[0];
+               results[1] = data->status[1];
+               results[2] = data->status[2];
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               printk
+                   ("bt869.o: Warning: write was requested on read-only proc file: status\n");
+       }
+}
+
+
+void bt869_ntsc(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       struct bt869_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               bt869_update_client(client);
+               results[0] = data->ntsc;
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->ntsc = (results[0] > 0);
+               }
+               bt869_update_client(client);
+       }
+}
+
+
+void bt869_svideo(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       struct bt869_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               bt869_update_client(client);
+               results[0] = data->svideo;
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->svideo = results[0];
+               }
+               bt869_update_client(client);
+       }
+}
+
+
+void bt869_res(struct i2c_client *client, int operation, int ctl_name,
+              int *nrels_mag, long *results)
+{
+       struct bt869_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               bt869_update_client(client);
+               results[0] = data->res[0];
+               results[1] = data->res[1];
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->res[0] = results[0];
+               }
+               if (*nrels_mag >= 2) {
+                       data->res[1] = results[1];
+               }
+               bt869_update_client(client);
+       }
+}
+
+
+void bt869_half(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       struct bt869_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               bt869_update_client(client);
+               results[0] = data->half;
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->half = (results[0] > 0);
+                       bt869_update_client(client);
+               }
+       }
+}
+
+void bt869_colorbars(struct i2c_client *client, int operation,
+                    int ctl_name, int *nrels_mag, long *results)
+{
+       struct bt869_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               bt869_update_client(client);
+               results[0] = data->colorbars;
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->colorbars = (results[0] > 0);
+                       bt869_update_client(client);
+               }
+       }
+}
+
+void bt869_depth(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct bt869_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               bt869_update_client(client);
+               results[0] = data->depth;
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->depth = results[0];
+                       bt869_update_client(client);
+               }
+       }
+}
+
+static int __init sm_bt869_init(void)
+{
+       printk("bt869.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       return i2c_add_driver(&bt869_driver);
+}
+
+static void __exit sm_bt869_exit(void)
+{
+       i2c_del_driver(&bt869_driver);
+}
+
+
+
+MODULE_AUTHOR
+    ("Frodo Looijaard <frodol@dds.nl>, Philip Edelbrock <phil@netroedge.com>, Stephen Davies <steve@daviesfam.org>");
+MODULE_DESCRIPTION("bt869 driver");
+
+module_init(sm_bt869_init);
+module_exit(sm_bt869_exit);
--- linux-old/drivers/sensors/ddcmon.c  Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/ddcmon.c      Mon Dec 13 20:18:45 2004
@@ -0,0 +1,591 @@
+/*
+    ddcmon.c - Part of lm_sensors, Linux kernel modules for hardware
+               monitoring
+    Copyright (c) 1998, 1999, 2000  Frodo Looijaard <frodol@dds.nl>,
+    Philip Edelbrock <phil@netroedge.com>,
+    and Mark Studebaker <mdsxyz123@yahoo.com>
+    Copyright (c) 2003  Jean Delvare <khali@linux-fr.org>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+MODULE_LICENSE("GPL");
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = { 0x50, SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { SENSORS_I2C_END };
+static unsigned int normal_isa[] = { SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+/* Insmod parameters */
+SENSORS_INSMOD_1(ddcmon);
+
+static int checksum = 0;
+MODULE_PARM(checksum, "i");
+MODULE_PARM_DESC(checksum, "Only accept eeproms whose checksum is correct");
+
+/* Many constants specified below */
+
+/* DDCMON registers */
+/* vendor section */
+#define DDCMON_REG_MAN_ID 0x08
+#define DDCMON_REG_PROD_ID 0x0A
+#define DDCMON_REG_SERIAL 0x0C
+#define DDCMON_REG_WEEK 0x10
+#define DDCMON_REG_YEAR 0x11
+/* EDID version */
+#define DDCMON_REG_EDID_VER 0x12
+#define DDCMON_REG_EDID_REV 0x13
+/* display information */
+#define DDCMON_REG_HORSIZE 0x15
+#define DDCMON_REG_VERSIZE 0x16
+#define DDCMON_REG_GAMMA 0x17
+#define DDCMON_REG_DPMS_FLAGS 0x18
+/* supported timings */
+#define DDCMON_REG_ESTABLISHED_TIMINGS 0x23
+#define DDCMON_REG_STANDARD_TIMINGS 0x26
+#define DDCMON_REG_TIMBASE 0x36
+#define DDCMON_REG_TIMINCR 18
+#define DDCMON_REG_TIMNUM   4
+
+#define DDCMON_REG_CHECKSUM 0x7f
+
+/* Size of DDCMON in bytes */
+#define DDCMON_SIZE 128
+
+/* Each client has this additional data */
+struct ddcmon_data {
+       struct i2c_client client;
+       int sysctl_id;
+
+       struct semaphore update_lock;
+       char valid;             /* !=0 if following fields are valid */
+       unsigned long last_updated;     /* In jiffies */
+
+       u8 data[DDCMON_SIZE];   /* Register values */
+};
+
+
+static int ddcmon_attach_adapter(struct i2c_adapter *adapter);
+static int ddcmon_detect(struct i2c_adapter *adapter, int address,
+                        unsigned short flags, int kind);
+static int ddcmon_detach_client(struct i2c_client *client);
+
+static void ddcmon_idcall(struct i2c_client *client, int operation,
+                           int ctl_name, int *nrels_mag, long *results);
+static void ddcmon_size(struct i2c_client *client, int operation,
+                           int ctl_name, int *nrels_mag, long *results);
+static void ddcmon_sync(struct i2c_client *client, int operation,
+                           int ctl_name, int *nrels_mag, long *results);
+static void ddcmon_maxclock(struct i2c_client *client, int operation,
+                           int ctl_name, int *nrels_mag, long *results);
+static void ddcmon_timings(struct i2c_client *client, int operation,
+                           int ctl_name, int *nrels_mag, long *results);
+static void ddcmon_serial(struct i2c_client *client, int operation,
+                           int ctl_name, int *nrels_mag, long *results);
+static void ddcmon_time(struct i2c_client *client, int operation,
+                           int ctl_name, int *nrels_mag, long *results);
+static void ddcmon_edid(struct i2c_client *client, int operation,
+                           int ctl_name, int *nrels_mag, long *results);
+static void ddcmon_gamma(struct i2c_client *client, int operation,
+                           int ctl_name, int *nrels_mag, long *results);
+static void ddcmon_dpms(struct i2c_client *client, int operation,
+                           int ctl_name, int *nrels_mag, long *results);
+static void ddcmon_standard_timing(struct i2c_client *client, int operation,
+                           int ctl_name, int *nrels_mag, long *results);
+static void ddcmon_update_client(struct i2c_client *client);
+
+
+/* This is the driver that will be inserted */
+static struct i2c_driver ddcmon_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "DDCMON READER",
+       .id             = I2C_DRIVERID_DDCMON,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = ddcmon_attach_adapter,
+       .detach_client  = ddcmon_detach_client,
+};
+
+/* -- SENSORS SYSCTL START -- */
+
+#define DDCMON_SYSCTL_ID 1010
+#define DDCMON_SYSCTL_SIZE 1011
+#define DDCMON_SYSCTL_SYNC 1012
+#define DDCMON_SYSCTL_TIMINGS 1013
+#define DDCMON_SYSCTL_SERIAL 1014
+#define DDCMON_SYSCTL_TIME 1015
+#define DDCMON_SYSCTL_EDID 1016
+#define DDCMON_SYSCTL_GAMMA 1017
+#define DDCMON_SYSCTL_DPMS 1018
+#define DDCMON_SYSCTL_TIMING1 1021
+#define DDCMON_SYSCTL_TIMING2 1022
+#define DDCMON_SYSCTL_TIMING3 1023
+#define DDCMON_SYSCTL_TIMING4 1024
+#define DDCMON_SYSCTL_TIMING5 1025
+#define DDCMON_SYSCTL_TIMING6 1026
+#define DDCMON_SYSCTL_TIMING7 1027
+#define DDCMON_SYSCTL_TIMING8 1028
+#define DDCMON_SYSCTL_MAXCLOCK 1029
+
+/* -- SENSORS SYSCTL END -- */
+
+/* These files are created for each detected DDCMON. This is just a template;
+   though at first sight, you might think we could use a statically
+   allocated list, we need some way to get back to the parent - which
+   is done through one of the 'extra' fields which are initialized
+   when a new copy is allocated. */
+static ctl_table ddcmon_dir_table_template[] = {
+       {DDCMON_SYSCTL_ID, "id", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &ddcmon_idcall},
+       {DDCMON_SYSCTL_SIZE, "size", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &ddcmon_size},
+       {DDCMON_SYSCTL_SYNC, "sync", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &ddcmon_sync},
+       {DDCMON_SYSCTL_TIMINGS, "timings", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &ddcmon_timings},
+       {DDCMON_SYSCTL_SERIAL, "serial", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &ddcmon_serial},
+       {DDCMON_SYSCTL_TIME, "time", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &ddcmon_time},
+       {DDCMON_SYSCTL_EDID, "edid", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &ddcmon_edid},
+       {DDCMON_SYSCTL_GAMMA, "gamma", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &ddcmon_gamma},
+       {DDCMON_SYSCTL_DPMS, "dpms", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &ddcmon_dpms},
+       {DDCMON_SYSCTL_TIMING1, "timing1", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &ddcmon_standard_timing},
+       {DDCMON_SYSCTL_TIMING2, "timing2", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &ddcmon_standard_timing},
+       {DDCMON_SYSCTL_TIMING3, "timing3", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &ddcmon_standard_timing},
+       {DDCMON_SYSCTL_TIMING4, "timing4", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &ddcmon_standard_timing},
+       {DDCMON_SYSCTL_TIMING5, "timing5", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &ddcmon_standard_timing},
+       {DDCMON_SYSCTL_TIMING6, "timing6", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &ddcmon_standard_timing},
+       {DDCMON_SYSCTL_TIMING7, "timing7", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &ddcmon_standard_timing},
+       {DDCMON_SYSCTL_TIMING8, "timing8", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &ddcmon_standard_timing},
+       {DDCMON_SYSCTL_MAXCLOCK, "maxclock", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &ddcmon_maxclock},
+       {0}
+};
+
+static int ddcmon_id = 0;
+
+static int ddcmon_attach_adapter(struct i2c_adapter *adapter)
+{
+       return i2c_detect(adapter, &addr_data, ddcmon_detect);
+}
+
+/* This function is called by i2c_detect */
+int ddcmon_detect(struct i2c_adapter *adapter, int address,
+                 unsigned short flags, int kind)
+{
+       int i, cs;
+       struct i2c_client *new_client;
+       struct ddcmon_data *data;
+       int err = 0;
+       const char *type_name, *client_name;
+
+       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
+                   goto ERROR0;
+
+       /* OK. For now, we presume we have a valid client. We now create the
+          client structure, even though we cannot fill it completely yet.
+          But it allows us to access ddcmon_{read,write}_value. */
+       if (!(data = kmalloc(sizeof(struct ddcmon_data), GFP_KERNEL))) {
+               err = -ENOMEM;
+               goto ERROR0;
+       }
+
+       new_client = &data->client;
+       memset(data->data, 0xff, DDCMON_SIZE);
+       new_client->addr = address;
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &ddcmon_driver;
+       new_client->flags = 0;
+
+       /* prevent 24RF08 corruption (just in case) */
+       i2c_smbus_write_quick(new_client, 0);
+
+       /* Now, we do the remaining detection. */
+       if (checksum) {
+               int cs = 0;
+               for (i = 0; i < 0x80; i++)
+                       cs += i2c_smbus_read_byte_data(new_client, i);
+               if ((cs & 0xff) != 0)
+                       goto ERROR1;
+       }
+
+       /* Verify the first 8 locations 0x00FFFFFFFFFFFF00 */
+       /* Allow force and force_ddcmon arguments */
+       if(kind < 0)
+       {
+               for(i = 0; i < 8; i++) {
+                       cs = i2c_smbus_read_byte_data(new_client, i);
+                       if(i == 0 || i == 7) {
+                               if(cs != 0)
+                                       goto ERROR1;
+                       } else if(cs != 0xff)
+                               goto ERROR1;
+               }
+       }
+
+       type_name = "ddcmon";
+       client_name = "DDC Monitor";
+
+       /* Fill in the remaining client fields and put it in the global list */
+       strcpy(new_client->name, client_name);
+
+       new_client->id = ddcmon_id++;
+       data->valid = 0;
+       init_MUTEX(&data->update_lock);
+
+       /* Tell the I2C layer a new client has arrived */
+       if ((err = i2c_attach_client(new_client)))
+               goto ERROR3;
+
+       /* Register a new directory entry with module sensors */
+       if ((i = i2c_register_entry(new_client, type_name,
+                                       ddcmon_dir_table_template)) < 0) {
+               err = i;
+               goto ERROR4;
+       }
+       data->sysctl_id = i;
+
+       return 0;
+
+      ERROR4:
+       i2c_detach_client(new_client);
+      ERROR3:
+      ERROR1:
+       kfree(data);
+      ERROR0:
+       return err;
+}
+
+static int ddcmon_detach_client(struct i2c_client *client)
+{
+       int err;
+
+       i2c_deregister_entry(((struct ddcmon_data *) (client->data))->
+                                sysctl_id);
+       if ((err = i2c_detach_client(client))) {
+               printk
+                   ("ddcmon.o: Client deregistration failed, client not detached.\n");
+               return err;
+       }
+       kfree(client->data);
+       return 0;
+}
+
+static void ddcmon_update_client(struct i2c_client *client)
+{
+       struct ddcmon_data *data = client->data;
+       int i, j;
+
+       down(&data->update_lock);
+
+       if ((jiffies - data->last_updated > 300 * HZ) ||
+           (jiffies < data->last_updated) || !data->valid) {
+               if (i2c_check_functionality(client->adapter,
+                                           I2C_FUNC_SMBUS_READ_I2C_BLOCK))
+               {
+                       for (i=0; i<DDCMON_SIZE; i+=I2C_SMBUS_I2C_BLOCK_MAX)
+                               if (i2c_smbus_read_i2c_block_data(client,
+                                                          i, data->data + i)
+                                                   != I2C_SMBUS_I2C_BLOCK_MAX) {
+                                       printk(KERN_WARNING "ddcmon.o: block read fail at 0x%.2x!\n", i);
+                                       goto DONE;
+                               }
+               } else {
+                       if (i2c_smbus_write_byte(client, 0)) {
+                               printk(KERN_WARNING "ddcmon.o: read start fail at 0!\n");
+                               goto DONE;
+                       }
+                       for (i = 0; i < DDCMON_SIZE; i++) {
+                               j = i2c_smbus_read_byte(client);
+                               if (j < 0) {
+                                       printk(KERN_WARNING "eeprom.o: read fail at 0x%.2x!\n", i);
+                                       goto DONE;
+                               }
+                               data->data[i] = (u8) j;
+                       }
+               }
+               data->last_updated = jiffies;
+               data->valid = 1;
+       }
+DONE:
+       up(&data->update_lock);
+}
+
+
+void ddcmon_idcall(struct i2c_client *client, int operation,
+                  int ctl_name, int *nrels_mag, long *results)
+{
+       struct ddcmon_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               ddcmon_update_client(client);
+               results[0] = data->data[DDCMON_REG_MAN_ID + 1] |
+                            (data->data[DDCMON_REG_MAN_ID] << 8);
+               results[1] = data->data[DDCMON_REG_PROD_ID + 1] |
+                            (data->data[DDCMON_REG_PROD_ID] << 8);
+               *nrels_mag = 2;
+       }
+}
+
+void ddcmon_size(struct i2c_client *client, int operation,
+                int ctl_name, int *nrels_mag, long *results)
+{
+       struct ddcmon_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               ddcmon_update_client(client);
+               results[0] = data->data[DDCMON_REG_VERSIZE];
+               results[1] = data->data[DDCMON_REG_HORSIZE];
+               *nrels_mag = 2;
+       }
+}
+
+void ddcmon_sync(struct i2c_client *client, int operation,
+                   int ctl_name, int *nrels_mag, long *results)
+{
+       int i, j;
+       struct ddcmon_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               ddcmon_update_client(client);
+               *nrels_mag = 4;
+               /* look for monitor limits entry */
+               for(i = DDCMON_REG_TIMBASE;
+                   i < DDCMON_REG_TIMBASE +
+                       (DDCMON_REG_TIMNUM * DDCMON_REG_TIMINCR);
+                   i += DDCMON_REG_TIMINCR) {
+                       if (data->data[i] == 0x00
+                        && data->data[i + 1] == 0x00
+                        && data->data[i + 2] == 0x00
+                        && data->data[i + 3] == 0xfd) {
+                               for(j = 0; j < 4; j++)
+                                       results[j] = data->data[i + j + 5];
+                               return;
+                       }
+               }
+               for(j = 0; j < 4; j++)
+                       results[j] = 0;
+       }
+}
+
+void ddcmon_maxclock(struct i2c_client *client, int operation,
+                   int ctl_name, int *nrels_mag, long *results)
+{
+       int i;
+       struct ddcmon_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               ddcmon_update_client(client);
+               *nrels_mag = 1;
+               /* look for monitor limits entry */
+               for(i = DDCMON_REG_TIMBASE;
+                   i < DDCMON_REG_TIMBASE +
+                       (DDCMON_REG_TIMNUM * DDCMON_REG_TIMINCR);
+                   i += DDCMON_REG_TIMINCR) {
+                       if (data->data[i] == 0x00
+                        && data->data[i + 1] == 0x00
+                        && data->data[i + 2] == 0x00
+                        && data->data[i + 3] == 0xfd) {
+                               results[0] = (data->data[i + 9] == 0xff ?
+                                            0 : data->data[i + 9] * 10);
+                               return;
+                       }
+               }
+               results[0] = 0;
+       }
+}
+
+void ddcmon_timings(struct i2c_client *client, int operation,
+                   int ctl_name, int *nrels_mag, long *results)
+{
+       struct ddcmon_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               ddcmon_update_client(client);
+               results[0] = data->data[DDCMON_REG_ESTABLISHED_TIMINGS] |
+                            (data->data[DDCMON_REG_ESTABLISHED_TIMINGS + 1] << 8) |
+                            (data->data[DDCMON_REG_ESTABLISHED_TIMINGS + 2] << 16);
+               *nrels_mag = 1;
+       }
+}
+
+void ddcmon_serial(struct i2c_client *client, int operation,
+                   int ctl_name, int *nrels_mag, long *results)
+{
+       struct ddcmon_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               ddcmon_update_client(client);
+               results[0] = data->data[DDCMON_REG_SERIAL] |
+                            (data->data[DDCMON_REG_SERIAL + 1] << 8) |
+                            (data->data[DDCMON_REG_SERIAL + 2] << 16) |
+                            (data->data[DDCMON_REG_SERIAL + 3] << 24);
+               *nrels_mag = 1;
+       }
+}
+
+void ddcmon_time(struct i2c_client *client, int operation,
+                int ctl_name, int *nrels_mag, long *results)
+{
+       struct ddcmon_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               ddcmon_update_client(client);
+               results[0] = data->data[DDCMON_REG_YEAR] + 1990;
+               results[1] = data->data[DDCMON_REG_WEEK];
+               *nrels_mag = 2;
+       }
+}
+
+void ddcmon_edid(struct i2c_client *client, int operation,
+                int ctl_name, int *nrels_mag, long *results)
+{
+       struct ddcmon_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               ddcmon_update_client(client);
+               results[0] = data->data[DDCMON_REG_EDID_VER];
+               results[1] = data->data[DDCMON_REG_EDID_REV];
+               *nrels_mag = 2;
+       }
+}
+
+void ddcmon_gamma(struct i2c_client *client, int operation,
+                int ctl_name, int *nrels_mag, long *results)
+{
+       struct ddcmon_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 2;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               ddcmon_update_client(client);
+               results[0] = 100 + data->data[DDCMON_REG_GAMMA];
+               *nrels_mag = 1;
+       }
+}
+
+void ddcmon_dpms(struct i2c_client *client, int operation,
+                int ctl_name, int *nrels_mag, long *results)
+{
+       struct ddcmon_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               ddcmon_update_client(client);
+               results[0] = data->data[DDCMON_REG_DPMS_FLAGS];
+               *nrels_mag = 1;
+       }
+}
+
+void ddcmon_standard_timing(struct i2c_client *client, int operation,
+                int ctl_name, int *nrels_mag, long *results)
+{
+       struct ddcmon_data *data = client->data;
+       int nr = ctl_name - DDCMON_SYSCTL_TIMING1;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               ddcmon_update_client(client);
+               /* If both bytes of the timing are 0x00 or 0x01, then the timing
+                  slot is unused. */
+               if ((data->data[DDCMON_REG_STANDARD_TIMINGS + nr * 2]
+                   | data->data[DDCMON_REG_STANDARD_TIMINGS + nr * 2 + 1]) & 0xfe) {
+                       results[0] = (data->data[DDCMON_REG_STANDARD_TIMINGS + nr * 2] + 31) * 8;
+                       switch (data->data[DDCMON_REG_STANDARD_TIMINGS + nr * 2 + 1] >> 6) {
+                               /* We don't care about rounding issues there, it really
+                                  should be OK without it. */
+                               case 0x00:
+                                       results[1] = results[0]; /* unconfirmed */
+                                       break;
+                               case 0x01:
+                                       results[1] = results[0] * 3 / 4;
+                                       break;
+                               case 0x02:
+                                       results[1] = results[0] * 4 / 5;
+                                       break;
+                               case 0x03:
+                                       results[1] = results[0] * 9 / 16;
+                                       break;
+                       }
+                       results[2] = (data->data[DDCMON_REG_STANDARD_TIMINGS + nr * 2 + 1] & 0x3f) + 60;
+               } else {
+                       results[0] = 0;
+                       results[1] = 0;
+                       results[2] = 0;
+               }
+               *nrels_mag = 3;
+       }
+}
+
+static int __init sm_ddcmon_init(void)
+{
+       printk("ddcmon.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       return i2c_add_driver(&ddcmon_driver);
+}
+
+static void __exit sm_ddcmon_exit(void)
+{
+       i2c_del_driver(&ddcmon_driver);
+}
+
+
+
+MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>, "
+             "Philip Edelbrock <phil@netroedge.com>, "
+             "Mark Studebaker <mdsxyz123@yahoo.com> "
+                 "and Jean Delvare <khali@linux-fr.org>");
+MODULE_DESCRIPTION("DDCMON driver");
+
+module_init(sm_ddcmon_init);
+module_exit(sm_ddcmon_exit);
--- linux-old/drivers/sensors/ds1621.c  Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/ds1621.c      Mon Dec 13 20:18:45 2004
@@ -0,0 +1,528 @@
+/*
+    ds1621.c - Part of lm_sensors, Linux kernel modules for hardware
+             monitoring
+    Christian W. Zuckschwerdt  <zany@triq.net>  2000-11-23
+    based on lm75.c by Frodo Looijaard <frodol@dds.nl>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/* Supports DS1621. See doc/chips/ds1621 for details */
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+MODULE_LICENSE("GPL");
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = { SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { 0x48, 0x4f, SENSORS_I2C_END };
+static unsigned int normal_isa[] = { SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+/* Insmod parameters */
+SENSORS_INSMOD_1(ds1621);
+
+/* Many DS1621 constants specified below */
+
+/* Config register used for detection         */
+/*  7    6    5    4    3    2    1    0      */
+/* |Done|THF |TLF |NVB | 1  | 0  |POL |1SHOT| */
+#define DS1621_REG_CONFIG_MASK 0x0C
+#define DS1621_REG_CONFIG_VAL 0x08
+#define DS1621_REG_CONFIG_POLARITY 0x02
+#define DS1621_REG_CONFIG_1SHOT 0x01
+#define DS1621_REG_CONFIG_DONE 0x80
+
+/* Note: the done bit is always unset if continuous conversion is in progress.
+         We need to stop the continuous conversion or switch to single shot
+         before this bit becomes available!
+ */
+
+/* The DS1621 registers */
+#define DS1621_REG_TEMP 0xAA /* word, RO */
+#define DS1621_REG_TEMP_OVER 0xA1 /* word, RW */
+#define DS1621_REG_TEMP_HYST 0xA2 /* word, RW -- it's a low temp trigger */
+#define DS1621_REG_CONF 0xAC /* byte, RW */
+#define DS1621_REG_TEMP_COUNTER 0xA8 /* byte, RO */
+#define DS1621_REG_TEMP_SLOPE 0xA9 /* byte, RO */
+#define DS1621_COM_START 0xEE /* no data */
+#define DS1621_COM_STOP 0x22 /* no data */
+
+/* Conversions. Rounding and limit checking is only done on the TO_REG
+   variants. Note that you should be a bit careful with which arguments
+   these macros are called: arguments may be evaluated more than once.
+   Fixing this is just not worth it. */
+#define TEMP_FROM_REG(val) ((((val & 0x7fff) >> 7) * 5) | \
+                            ((val & 0x8000)?-256:0))
+#define TEMP_TO_REG(val)   (SENSORS_LIMIT((val<0 ? (0x200+((val)/5))<<7 : \
+                                          (((val) + 2) / 5) << 7),0,0xffff))
+#define ALARMS_FROM_REG(val) ((val) & \
+                              (DS1621_ALARM_TEMP_HIGH | DS1621_ALARM_TEMP_LOW))
+#define ITEMP_FROM_REG(val) ((((val & 0x7fff) >> 8)) | \
+                            ((val & 0x8000)?-256:0))
+
+/* Each client has this additional data */
+struct ds1621_data {
+       struct i2c_client client;
+       int sysctl_id;
+
+       struct semaphore update_lock;
+       char valid;             /* !=0 if following fields are valid */
+       unsigned long last_updated;     /* In jiffies */
+
+       u16 temp, temp_over, temp_hyst; /* Register values, word */
+       u8 conf;                        /* Register encoding, combined */
+
+       char enable;    /* !=0 if we're expected to restart the conversion */
+       u8 temp_int, temp_counter, temp_slope;  /* Register values, byte */
+};
+
+static int ds1621_attach_adapter(struct i2c_adapter *adapter);
+static int ds1621_detect(struct i2c_adapter *adapter, int address,
+                        unsigned short flags, int kind);
+static void ds1621_init_client(struct i2c_client *client);
+static int ds1621_detach_client(struct i2c_client *client);
+
+static int ds1621_read_value(struct i2c_client *client, u8 reg);
+static int ds1621_write_value(struct i2c_client *client, u8 reg, u16 value);
+static void ds1621_temp(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void ds1621_alarms(struct i2c_client *client, int operation,
+                         int ctl_name, int *nrels_mag, long *results);
+static void ds1621_enable(struct i2c_client *client, int operation,
+                         int ctl_name, int *nrels_mag, long *results);
+static void ds1621_continuous(struct i2c_client *client, int operation,
+                             int ctl_name, int *nrels_mag, long *results);
+static void ds1621_polarity(struct i2c_client *client, int operation,
+                           int ctl_name, int *nrels_mag, long *results);
+static void ds1621_update_client(struct i2c_client *client);
+
+
+/* This is the driver that will be inserted */
+static struct i2c_driver ds1621_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "DS1621 sensor driver",
+       .id             = I2C_DRIVERID_DS1621,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = ds1621_attach_adapter,
+       .detach_client  = ds1621_detach_client,
+};
+
+/* -- SENSORS SYSCTL START -- */
+#define DS1621_SYSCTL_TEMP 1200        /* Degrees Celcius * 10 */
+#define DS1621_SYSCTL_ALARMS 2001      /* bitvector */
+#define DS1621_ALARM_TEMP_HIGH 0x40
+#define DS1621_ALARM_TEMP_LOW 0x20
+#define DS1621_SYSCTL_ENABLE 2002
+#define DS1621_SYSCTL_CONTINUOUS 2003
+#define DS1621_SYSCTL_POLARITY 2004
+
+/* -- SENSORS SYSCTL END -- */
+
+/* These files are created for each detected DS1621. This is just a template;
+   though at first sight, you might think we could use a statically
+   allocated list, we need some way to get back to the parent - which
+   is done through one of the 'extra' fields which are initialized
+   when a new copy is allocated. */
+static ctl_table ds1621_dir_table_template[] = {
+       {DS1621_SYSCTL_TEMP, "temp", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &ds1621_temp},
+       {DS1621_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &ds1621_alarms},
+       {DS1621_SYSCTL_ENABLE, "enable", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &ds1621_enable},
+       {DS1621_SYSCTL_CONTINUOUS, "continuous", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &ds1621_continuous},
+       {DS1621_SYSCTL_POLARITY, "polarity", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &ds1621_polarity},
+       {0}
+};
+
+static int ds1621_id = 0;
+
+static int ds1621_attach_adapter(struct i2c_adapter *adapter)
+{
+       return i2c_detect(adapter, &addr_data, ds1621_detect);
+}
+
+/* This function is called by i2c_detect */
+int ds1621_detect(struct i2c_adapter *adapter, int address,
+               unsigned short flags, int kind)
+{
+       int i, conf;
+       struct i2c_client *new_client;
+       struct ds1621_data *data;
+       int err = 0;
+       const char *type_name, *client_name;
+
+       /* Make sure we aren't probing the ISA bus!! This is just a safety check
+          at this moment; i2c_detect really won't call us. */
+#ifdef DEBUG
+       if (i2c_is_isa_adapter(adapter)) {
+               printk
+                ("ds1621.o: ds1621_detect called for an ISA bus adapter?!?\n");
+               return 0;
+       }
+#endif
+
+       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
+                                    I2C_FUNC_SMBUS_WORD_DATA |
+                                    I2C_FUNC_SMBUS_WRITE_BYTE))
+                   goto ERROR0;
+
+       /* OK. For now, we presume we have a valid client. We now create the
+          client structure, even though we cannot fill it completely yet.
+          But it allows us to access ds1621_{read,write}_value. */
+       if (!(data = kmalloc(sizeof(struct ds1621_data), GFP_KERNEL))) {
+               err = -ENOMEM;
+               goto ERROR0;
+       }
+
+       new_client = &data->client;
+       new_client->addr = address;
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &ds1621_driver;
+       new_client->flags = 0;
+
+       /* Now, we do the remaining detection. It is lousy. */
+       if (kind < 0) {
+               conf = i2c_smbus_read_byte_data(new_client,
+                                               DS1621_REG_CONF);
+               if ((conf & DS1621_REG_CONFIG_MASK)
+                   != DS1621_REG_CONFIG_VAL)
+                       goto ERROR1;
+       }
+
+       /* Determine the chip type - only one kind supported! */
+       if (kind <= 0)
+               kind = ds1621;
+
+       if (kind == ds1621) {
+               type_name = "ds1621";
+               client_name = "DS1621 chip";
+       } else {
+#ifdef DEBUG
+               printk("ds1621.o: Internal error: unknown kind (%d)?!?",
+                      kind);
+#endif
+               goto ERROR1;
+       }
+
+       /* Fill in remaining client fields and put it into the global list */
+       strcpy(new_client->name, client_name);
+
+       new_client->id = ds1621_id++;
+       data->valid = 0;
+       init_MUTEX(&data->update_lock);
+
+       /* Tell the I2C layer a new client has arrived */
+       if ((err = i2c_attach_client(new_client)))
+               goto ERROR3;
+
+       /* Register a new directory entry with module sensors */
+       if ((i = i2c_register_entry(new_client, type_name,
+                                       ds1621_dir_table_template)) < 0) {
+               err = i;
+               goto ERROR4;
+       }
+       data->sysctl_id = i;
+
+       ds1621_init_client(new_client);
+       return 0;
+
+/* OK, this is not exactly good programming practice, usually. But it is
+   very code-efficient in this case. */
+
+      ERROR4:
+       i2c_detach_client(new_client);
+      ERROR3:
+      ERROR1:
+       kfree(data);
+      ERROR0:
+       return err;
+}
+
+static int ds1621_detach_client(struct i2c_client *client)
+{
+       int err;
+
+       i2c_deregister_entry(((struct ds1621_data *) (client->data))->
+                                sysctl_id);
+
+       if ((err = i2c_detach_client(client))) {
+               printk
+          ("ds1621.o: Client deregistration failed, client not detached.\n");
+               return err;
+       }
+
+       kfree(client->data);
+
+       return 0;
+}
+
+
+/* All registers are word-sized, except for the configuration register.
+   DS1621 uses a high-byte first convention, which is exactly opposite to
+   the usual practice. */
+static int ds1621_read_value(struct i2c_client *client, u8 reg)
+{
+       if ((reg == DS1621_REG_CONF) || (reg == DS1621_REG_TEMP_COUNTER)
+           || (reg == DS1621_REG_TEMP_SLOPE))
+               return i2c_smbus_read_byte_data(client, reg);
+       else
+               return swab16(i2c_smbus_read_word_data(client, reg));
+}
+
+/* All registers are word-sized, except for the configuration register.
+   DS1621 uses a high-byte first convention, which is exactly opposite to
+   the usual practice. */
+static int ds1621_write_value(struct i2c_client *client, u8 reg, u16 value)
+{
+       if ( (reg == DS1621_COM_START) || (reg == DS1621_COM_STOP) )
+               return i2c_smbus_write_byte(client, reg);
+       else
+       if ((reg == DS1621_REG_CONF) || (reg == DS1621_REG_TEMP_COUNTER)
+           || (reg == DS1621_REG_TEMP_SLOPE))
+               return i2c_smbus_write_byte_data(client, reg, value);
+       else
+               return i2c_smbus_write_word_data(client, reg, swab16(value));
+}
+
+static void ds1621_init_client(struct i2c_client *client)
+{
+       int reg;
+
+       reg = ds1621_read_value(client, DS1621_REG_CONF);
+       /* start the continous conversion */
+       if(reg & 0x01)
+               ds1621_write_value(client, DS1621_REG_CONF, reg & 0xfe);
+}
+
+static void ds1621_update_client(struct i2c_client *client)
+{
+       struct ds1621_data *data = client->data;
+       u8 new_conf;
+
+       down(&data->update_lock);
+
+       if ((jiffies - data->last_updated > HZ + HZ / 2) ||
+           (jiffies < data->last_updated) || !data->valid) {
+
+#ifdef DEBUG
+               printk("Starting ds1621 update\n");
+#endif
+
+               data->conf = ds1621_read_value(client, DS1621_REG_CONF);
+
+               data->temp = ds1621_read_value(client,
+                                              DS1621_REG_TEMP);
+               data->temp_over = ds1621_read_value(client,
+                                                   DS1621_REG_TEMP_OVER);
+               data->temp_hyst = ds1621_read_value(client,
+                                                   DS1621_REG_TEMP_HYST);
+
+               /* wait for the DONE bit before reading extended values */
+
+               if (data->conf & DS1621_REG_CONFIG_DONE) {
+                       data->temp_counter = ds1621_read_value(client,
+                                                    DS1621_REG_TEMP_COUNTER);
+                       data->temp_slope = ds1621_read_value(client,
+                                                    DS1621_REG_TEMP_SLOPE);
+                       data->temp_int = ITEMP_FROM_REG(data->temp);
+                       /* restart the conversion */
+                       if (data->enable)
+                               ds1621_write_value(client, DS1621_COM_START, 0);
+               }
+
+               /* reset alarms if neccessary */
+               new_conf = data->conf;
+               if (data->temp < data->temp_over)
+                       new_conf &= ~DS1621_ALARM_TEMP_HIGH;
+               if (data->temp > data->temp_hyst)
+                       new_conf &= ~DS1621_ALARM_TEMP_LOW;
+               if (data->conf != new_conf)
+                       ds1621_write_value(client, DS1621_REG_CONF,
+                                          new_conf);
+
+               data->last_updated = jiffies;
+               data->valid = 1;
+       }
+
+       up(&data->update_lock);
+}
+
+
+void ds1621_temp(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct ds1621_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               if (!(data->conf & DS1621_REG_CONFIG_DONE) ||
+                   (data->temp_counter > data->temp_slope) ||
+                   (data->temp_slope == 0)) {
+                       *nrels_mag = 1;
+               } else {
+                       *nrels_mag = 2;
+               }
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               ds1621_update_client(client);
+               /* decide wether to calculate more precise temp */
+               if (!(data->conf & DS1621_REG_CONFIG_DONE) ||
+                   (data->temp_counter > data->temp_slope) ||
+                   (data->temp_slope == 0)) {
+                       results[0] = TEMP_FROM_REG(data->temp_over);
+                       results[1] = TEMP_FROM_REG(data->temp_hyst);
+                       results[2] = TEMP_FROM_REG(data->temp);
+               } else {
+                       results[0] = TEMP_FROM_REG(data->temp_over)*10;
+                       results[1] = TEMP_FROM_REG(data->temp_hyst)*10;
+                       results[2] = data->temp_int * 100 - 25 +
+                               ((data->temp_slope - data->temp_counter) *
+                                100 / data->temp_slope);
+               }
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->temp_over = TEMP_TO_REG(results[0]);
+                       ds1621_write_value(client, DS1621_REG_TEMP_OVER,
+                                        data->temp_over);
+               }
+               if (*nrels_mag >= 2) {
+                       data->temp_hyst = TEMP_TO_REG(results[1]);
+                       ds1621_write_value(client, DS1621_REG_TEMP_HYST,
+                                        data->temp_hyst);
+               }
+       }
+}
+
+void ds1621_alarms(struct i2c_client *client, int operation, int ctl_name,
+                  int *nrels_mag, long *results)
+{
+       struct ds1621_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               ds1621_update_client(client);
+               results[0] = ALARMS_FROM_REG(data->conf);
+               *nrels_mag = 1;
+       }
+}
+
+void ds1621_enable(struct i2c_client *client, int operation, int ctl_name,
+                  int *nrels_mag, long *results)
+{
+       /* If you really screw up your chip (like I did) this is */
+       /* sometimes needed to (re)start the continous conversion */
+       /* there is no data to read so this might hang your SMBus! */
+
+       struct ds1621_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               ds1621_update_client(client);
+               results[0] = !(data->conf & DS1621_REG_CONFIG_DONE);
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       if (results[0]) {
+                               ds1621_write_value(client, DS1621_COM_START, 0);
+                               data->enable=1;
+                       } else {
+                               ds1621_write_value(client, DS1621_COM_STOP, 0);
+                               data->enable=0;
+                       }
+               } else {
+                       ds1621_write_value(client, DS1621_COM_START, 0);
+                       data->enable=1;
+               }
+       }
+}
+
+void ds1621_continuous(struct i2c_client *client, int operation, int ctl_name,
+                      int *nrels_mag, long *results)
+{
+       struct ds1621_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               ds1621_update_client(client);
+               results[0] = !(data->conf & DS1621_REG_CONFIG_1SHOT);
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               ds1621_update_client(client);
+               if (*nrels_mag >= 1) {
+                       if (results[0]) {
+                               ds1621_write_value(client, DS1621_REG_CONF,
+                                                  data->conf & ~DS1621_REG_CONFIG_1SHOT);
+                       } else {
+                               ds1621_write_value(client, DS1621_REG_CONF,
+                                                  data->conf | DS1621_REG_CONFIG_1SHOT);
+                       }
+               } else {
+                       ds1621_write_value(client, DS1621_REG_CONF,
+                                          data->conf & ~DS1621_REG_CONFIG_1SHOT);
+               }
+       }
+}
+
+void ds1621_polarity(struct i2c_client *client, int operation, int ctl_name,
+                    int *nrels_mag, long *results)
+{
+       struct ds1621_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               ds1621_update_client(client);
+               results[0] = !(!(data->conf & DS1621_REG_CONFIG_POLARITY));
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               ds1621_update_client(client);
+               if (*nrels_mag >= 1) {
+                       if (results[0]) {
+                               ds1621_write_value(client, DS1621_REG_CONF,
+                                                  data->conf | DS1621_REG_CONFIG_POLARITY);
+                       } else {
+                               ds1621_write_value(client, DS1621_REG_CONF,
+                                                  data->conf & ~DS1621_REG_CONFIG_POLARITY);
+                       }
+               }
+       }
+}
+
+static int __init sm_ds1621_init(void)
+{
+       printk("ds1621.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       return i2c_add_driver(&ds1621_driver);
+}
+
+static void __exit sm_ds1621_exit(void)
+{
+       i2c_del_driver(&ds1621_driver);
+}
+
+
+
+MODULE_AUTHOR("Christian W. Zuckschwerdt <zany@triq.net>");
+MODULE_DESCRIPTION("DS1621 driver");
+
+module_init(sm_ds1621_init);
+module_exit(sm_ds1621_exit);
--- linux-old/drivers/sensors/eeprom.c  Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/eeprom.c      Mon Dec 13 20:18:45 2004
@@ -0,0 +1,418 @@
+/*
+    eeprom.c - Part of lm_sensors, Linux kernel modules for hardware
+               monitoring
+    Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl> and
+    Philip Edelbrock <phil@netroedge.com>
+
+    2003-08-18  Jean Delvare <khali@linux-fr.org>
+    Divide the eeprom in 2-row (arbitrary) slices. This significantly
+    speeds sensors up, as well as various scripts using the eeprom
+    module.
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#include <linux/sched.h> /* for capable() */
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+MODULE_LICENSE("GPL");
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = { SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { 0x50, 0x57, SENSORS_I2C_END };
+static unsigned int normal_isa[] = { SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+/* Insmod parameters */
+SENSORS_INSMOD_1(eeprom);
+
+static int checksum = 0;
+MODULE_PARM(checksum, "i");
+MODULE_PARM_DESC(checksum,
+                "Only accept eeproms whose checksum is correct");
+
+
+/* Many constants specified below */
+
+/* EEPROM registers */
+#define EEPROM_REG_CHECKSUM 0x3f
+
+/* possible natures */
+#define NATURE_UNKNOWN 0
+#define NATURE_VAIO 1
+
+/* Size of EEPROM in bytes */
+#define EEPROM_SIZE 256
+
+/* Each client has this additional data */
+struct eeprom_data {
+       struct i2c_client client;
+       int sysctl_id;
+
+       struct semaphore update_lock;
+       u8 valid;               /* bitfield, bit!=0 if slice is valid */
+       unsigned long last_updated[8];  /* In jiffies, 8 slices */
+
+       u8 data[EEPROM_SIZE];   /* Register values */
+       u8 nature;
+};
+
+
+static int eeprom_attach_adapter(struct i2c_adapter *adapter);
+static int eeprom_detect(struct i2c_adapter *adapter, int address,
+                        unsigned short flags, int kind);
+static int eeprom_detach_client(struct i2c_client *client);
+
+#if 0
+static int eeprom_write_value(struct i2c_client *client, u8 reg,
+                             u8 value);
+#endif
+
+static void eeprom_contents(struct i2c_client *client, int operation,
+                           int ctl_name, int *nrels_mag, long *results);
+static void eeprom_update_client(struct i2c_client *client, u8 slice);
+
+
+/* This is the driver that will be inserted */
+static struct i2c_driver eeprom_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "EEPROM READER",
+       .id             = I2C_DRIVERID_EEPROM,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = eeprom_attach_adapter,
+       .detach_client  = eeprom_detach_client,
+};
+
+/* -- SENSORS SYSCTL START -- */
+
+#define EEPROM_SYSCTL1 1000
+#define EEPROM_SYSCTL2 1001
+#define EEPROM_SYSCTL3 1002
+#define EEPROM_SYSCTL4 1003
+#define EEPROM_SYSCTL5 1004
+#define EEPROM_SYSCTL6 1005
+#define EEPROM_SYSCTL7 1006
+#define EEPROM_SYSCTL8 1007
+#define EEPROM_SYSCTL9 1008
+#define EEPROM_SYSCTL10 1009
+#define EEPROM_SYSCTL11 1010
+#define EEPROM_SYSCTL12 1011
+#define EEPROM_SYSCTL13 1012
+#define EEPROM_SYSCTL14 1013
+#define EEPROM_SYSCTL15 1014
+#define EEPROM_SYSCTL16 1015
+
+/* -- SENSORS SYSCTL END -- */
+
+/* These files are created for each detected EEPROM. This is just a template;
+   though at first sight, you might think we could use a statically
+   allocated list, we need some way to get back to the parent - which
+   is done through one of the 'extra' fields which are initialized
+   when a new copy is allocated. */
+static ctl_table eeprom_dir_table_template[] = {
+       {EEPROM_SYSCTL1, "00", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &eeprom_contents},
+       {EEPROM_SYSCTL2, "10", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &eeprom_contents},
+       {EEPROM_SYSCTL3, "20", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &eeprom_contents},
+       {EEPROM_SYSCTL4, "30", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &eeprom_contents},
+       {EEPROM_SYSCTL5, "40", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &eeprom_contents},
+       {EEPROM_SYSCTL6, "50", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &eeprom_contents},
+       {EEPROM_SYSCTL7, "60", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &eeprom_contents},
+       {EEPROM_SYSCTL8, "70", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &eeprom_contents},
+       {EEPROM_SYSCTL9, "80", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &eeprom_contents},
+       {EEPROM_SYSCTL10, "90", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &eeprom_contents},
+       {EEPROM_SYSCTL11, "a0", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &eeprom_contents},
+       {EEPROM_SYSCTL12, "b0", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &eeprom_contents},
+       {EEPROM_SYSCTL13, "c0", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &eeprom_contents},
+       {EEPROM_SYSCTL14, "d0", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &eeprom_contents},
+       {EEPROM_SYSCTL15, "e0", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &eeprom_contents},
+       {EEPROM_SYSCTL16, "f0", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &eeprom_contents},
+       {0}
+};
+
+static int eeprom_id = 0;
+
+static int eeprom_attach_adapter(struct i2c_adapter *adapter)
+{
+       return i2c_detect(adapter, &addr_data, eeprom_detect);
+}
+
+/* This function is called by i2c_detect */
+int eeprom_detect(struct i2c_adapter *adapter, int address,
+                 unsigned short flags, int kind)
+{
+       int i;
+       struct i2c_client *new_client;
+       struct eeprom_data *data;
+       int err = 0;
+       const char *type_name, *client_name;
+
+       /* Make sure we aren't probing the ISA bus!! This is just a safety check
+          at this moment; i2c_detect really won't call us. */
+#ifdef DEBUG
+       if (i2c_is_isa_adapter(adapter)) {
+               printk
+                   ("eeprom.o: eeprom_detect called for an ISA bus adapter?!?\n");
+               return 0;
+       }
+#endif
+
+       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
+                   goto ERROR0;
+
+       /* OK. For now, we presume we have a valid client. We now create the
+          client structure, even though we cannot fill it completely yet.
+          But it allows us to access eeprom_{read,write}_value. */
+       if (!(data = kmalloc(sizeof(struct eeprom_data), GFP_KERNEL))) {
+               err = -ENOMEM;
+               goto ERROR0;
+       }
+
+       new_client = &data->client;
+       memset(data->data, 0xff, EEPROM_SIZE);
+       new_client->addr = address;
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &eeprom_driver;
+       new_client->flags = 0;
+
+       /* prevent 24RF08 corruption */
+       i2c_smbus_write_quick(new_client, 0);
+
+       /* Now, we do the remaining detection. It is not there, unless you force
+          the checksum to work out. */
+       if (checksum) {
+               int cs = 0;
+               for (i = 0; i <= 0x3e; i++)
+                       cs += i2c_smbus_read_byte_data(new_client, i);
+               cs &= 0xff;
+               if (i2c_smbus_read_byte_data
+                   (new_client, EEPROM_REG_CHECKSUM) != cs)
+                       goto ERROR1;
+       }
+
+       data->nature = NATURE_UNKNOWN;
+       /* Detect the Vaio nature of EEPROMs.
+          We use the "PCG-" prefix as the signature. */
+       if (address == 0x57)
+       {
+               if (i2c_smbus_read_byte_data(new_client, 0x80) == 'P'
+                && i2c_smbus_read_byte_data(new_client, 0x81) == 'C'
+                && i2c_smbus_read_byte_data(new_client, 0x82) == 'G'
+                && i2c_smbus_read_byte_data(new_client, 0x83) == '-')
+                       data->nature = NATURE_VAIO;
+       }
+
+       /* Determine the chip type - only one kind supported! */
+       if (kind <= 0)
+               kind = eeprom;
+
+       if (kind == eeprom) {
+               type_name = "eeprom";
+               client_name = "EEPROM chip";
+       } else {
+#ifdef DEBUG
+               printk("eeprom.o: Internal error: unknown kind (%d)?!?",
+                      kind);
+#endif
+               goto ERROR1;
+       }
+
+       /* Fill in the remaining client fields and put it into the global list */
+       strcpy(new_client->name, client_name);
+
+       new_client->id = eeprom_id++;
+       data->valid = 0;
+       init_MUTEX(&data->update_lock);
+
+       /* Tell the I2C layer a new client has arrived */
+       if ((err = i2c_attach_client(new_client)))
+               goto ERROR3;
+
+       /* Register a new directory entry with module sensors */
+       if ((i = i2c_register_entry(new_client, type_name,
+                                       eeprom_dir_table_template)) < 0) {
+               err = i;
+               goto ERROR4;
+       }
+       data->sysctl_id = i;
+
+       return 0;
+
+/* OK, this is not exactly good programming practice, usually. But it is
+   very code-efficient in this case. */
+
+      ERROR4:
+       i2c_detach_client(new_client);
+      ERROR3:
+      ERROR1:
+       kfree(data);
+      ERROR0:
+       return err;
+}
+
+static int eeprom_detach_client(struct i2c_client *client)
+{
+       int err;
+
+       i2c_deregister_entry(((struct eeprom_data *) (client->data))->
+                                sysctl_id);
+
+       if ((err = i2c_detach_client(client))) {
+               printk
+                   ("eeprom.o: Client deregistration failed, client not detached.\n");
+               return err;
+       }
+
+       kfree(client->data);
+
+       return 0;
+}
+
+
+#if 0
+/* No writes yet (PAE) */
+static int eeprom_write_value(struct i2c_client *client, u8 reg, u8 value)
+{
+       return i2c_smbus_write_byte_data(client, reg, value);
+}
+#endif
+
+static void eeprom_update_client(struct i2c_client *client, u8 slice)
+{
+       struct eeprom_data *data = client->data;
+       int i, j;
+
+       down(&data->update_lock);
+
+       if (!(data->valid & (1 << slice))
+        || (jiffies - data->last_updated[slice] > 300 * HZ)
+        || (jiffies < data->last_updated[slice])) {
+
+#ifdef DEBUG
+               printk("Starting eeprom update, slice %u\n", slice);
+#endif
+
+               if (i2c_check_functionality(client->adapter,
+                                           I2C_FUNC_SMBUS_READ_I2C_BLOCK))
+               {
+                       for (i = slice << 5; i < (slice + 1) << 5;
+                                                   i += I2C_SMBUS_I2C_BLOCK_MAX)
+                               if (i2c_smbus_read_i2c_block_data(client,
+                                                          i, data->data + i)
+                                                   != I2C_SMBUS_I2C_BLOCK_MAX) {
+                                       printk(KERN_WARNING "eeprom.o: block read fail at 0x%.2x!\n", i);
+                                       goto DONE;
+                               }
+               } else {
+                       if (i2c_smbus_write_byte(client, slice << 5)) {
+                               printk(KERN_WARNING "eeprom.o: read start fail at 0x%.2x!\n", slice << 5);
+                               goto DONE;
+                       }
+                       for (i = slice << 5; i < (slice + 1) << 5; i++) {
+                               j = i2c_smbus_read_byte(client);
+                               if (j < 0) {
+                                       printk(KERN_WARNING "eeprom.o: read fail at 0x%.2x!\n", i);
+                                       goto DONE;
+                               }
+                               data->data[i] = (u8) j;
+                       }
+               }
+               data->last_updated[slice] = jiffies;
+               data->valid |= (1 << slice);
+       }
+DONE:
+       up(&data->update_lock);
+}
+
+
+void eeprom_contents(struct i2c_client *client, int operation,
+                    int ctl_name, int *nrels_mag, long *results)
+{
+       int i;
+       int nr = ctl_name - EEPROM_SYSCTL1;
+       struct eeprom_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               eeprom_update_client(client, nr >> 1);
+               /* Hide Vaio security settings to regular users */
+               if (nr == 0 && data->nature == NATURE_VAIO
+                && !capable(CAP_SYS_ADMIN))
+                       for (i = 0; i < 16; i++)
+                               results[i] = 0;
+               else
+                       for (i = 0; i < 16; i++)
+                               results[i] = data->data[i + nr * 16];
+#ifdef DEBUG
+               printk("eeprom.o: 0x%X EEPROM contents (row %d):",
+                      client->addr, nr + 1);
+               if (nr == 0 && data->nature == NATURE_VAIO)
+                       printk(" <hidden for security reasons>\n");
+               else {
+                       for (i = 0; i < 16; i++)
+                               printk(" 0x%02X", data->data[i + nr * 16]);
+                       printk("\n");
+               }
+#endif
+               *nrels_mag = 16;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+
+/* No writes to the EEPROM (yet, anyway) (PAE) */
+               printk("eeprom.o: No writes to EEPROMs supported!\n");
+       }
+}
+
+static int __init sm_eeprom_init(void)
+{
+       printk("eeprom.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       return i2c_add_driver(&eeprom_driver);
+}
+
+static void __exit sm_eeprom_exit(void)
+{
+       i2c_del_driver(&eeprom_driver);
+}
+
+
+
+MODULE_AUTHOR
+    ("Frodo Looijaard <frodol@dds.nl> and Philip Edelbrock <phil@netroedge.com>");
+MODULE_DESCRIPTION("EEPROM driver");
+
+module_init(sm_eeprom_init);
+module_exit(sm_eeprom_exit);
--- linux-old/drivers/sensors/fscpos.c  Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/fscpos.c      Mon Dec 13 20:18:46 2004
@@ -0,0 +1,690 @@
+/*
+    fscpos.c - Part of lm_sensors, Linux kernel modules for hardware
+             monitoring
+    Copyright (c) 2001 Hermann Jung <hej@odn.de>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/* 
+    fujitsu siemens poseidon chip, 
+    module based on lm80.c 
+    Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl>
+    and Philip Edelbrock <phil@netroedge.com>
+*/
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = { 0x73, SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { SENSORS_I2C_END };
+static unsigned int normal_isa[] = { SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+/* Insmod parameters */
+SENSORS_INSMOD_1(fscpos);
+
+/* The FSCPOS registers */
+
+/* chip identification */
+#define FSCPOS_REG_IDENT_0    0x00
+#define FSCPOS_REG_IDENT_1    0x01
+#define FSCPOS_REG_IDENT_2    0x02
+#define FSCPOS_REG_REVISION   0x03
+
+/* global control and status */
+#define FSCPOS_REG_EVENT_STATE  0x04
+#define FSCPOS_REG_CONTROL       0x05
+
+/* watchdog */
+#define FSCPOS_REG_WDOG_PRESET      0x28
+#define FSCPOS_REG_WDOG_STATE       0x23
+#define FSCPOS_REG_WDOG_CONTROL     0x21
+
+/* fan 0  */
+#define FSCPOS_REG_FAN0_MIN      0x55
+#define FSCPOS_REG_FAN0_ACT      0x0e
+#define FSCPOS_REG_FAN0_STATE   0x0d
+#define FSCPOS_REG_FAN0_RIPPLE   0x0f
+
+/* fan 1  */
+#define FSCPOS_REG_FAN1_MIN      0x65
+#define FSCPOS_REG_FAN1_ACT      0x6b
+#define FSCPOS_REG_FAN1_STATE   0x62
+#define FSCPOS_REG_FAN1_RIPPLE   0x6f
+
+/* fan 2  */
+/* min speed fan2 not supported */
+#define FSCPOS_REG_FAN2_ACT      0xab
+#define FSCPOS_REG_FAN2_STATE   0xa2
+#define FSCPOS_REG_FAN2_RIPPLE   0x0af
+
+/* voltage supervision */
+#define FSCPOS_REG_VOLT_12       0x45
+#define FSCPOS_REG_VOLT_5        0x42
+#define FSCPOS_REG_VOLT_BATT     0x48
+
+/* temperatures */
+/* sensor 0 */
+#define FSCPOS_REG_TEMP0_ACT       0x64
+#define FSCPOS_REG_TEMP0_STATE    0x71
+
+/* sensor 1 */
+#define FSCPOS_REG_TEMP1_ACT       0x32
+#define FSCPOS_REG_TEMP1_STATE    0x81
+
+/* sensor 2 */
+#define FSCPOS_REG_TEMP2_ACT       0x35
+#define FSCPOS_REG_TEMP2_STATE    0x91
+
+
+
+
+/* Conversions. Rounding and limit checking is only done on the TO_REG
+   variants. Note that you should be a bit careful with which arguments
+   these macros are called: arguments may be evaluated more than once.
+   Fixing this is just not worth it. */
+
+#define IN_TO_REG(val,nr) (SENSORS_LIMIT((val),0,255))
+#define IN_FROM_REG(val,nr) (val)
+
+/* Initial limits */
+
+/* For each registered FSCPOS, we need to keep some data in memory. That
+   data is pointed to by fscpos_list[NR]->data. The structure itself is
+   dynamically allocated, at the same time when a new fscpos client is
+   allocated. */
+struct fscpos_data {
+       struct i2c_client client;
+       int sysctl_id;
+
+       struct semaphore update_lock;
+       char valid;             /* !=0 if following fields are valid */
+       unsigned long last_updated;     /* In jiffies */
+
+       u8  revision;        /* revision of chip */
+       u8  global_event;    /* global event status */
+       u8  global_control;  /* global control register */
+       u8  watchdog[3];     /* watchdog */
+       u8  volt[3];         /* 12, 5, battery current */ 
+       u8  temp_act[3];     /* temperature */
+       u8  temp_status[3];  /* status of sensor */
+       u8  fan_act[3];      /* fans revolutions per second */
+       u8  fan_status[3];   /* fan status */
+       u8  fan_min[3];      /* fan min value for rps */
+       u8  fan_ripple[3];   /* divider for rps */
+};
+
+
+static int fscpos_attach_adapter(struct i2c_adapter *adapter);
+static int fscpos_detect(struct i2c_adapter *adapter, int address,
+                      unsigned short flags, int kind);
+static int fscpos_detach_client(struct i2c_client *client);
+
+static int fscpos_read_value(struct i2c_client *client, u8 register);
+static int fscpos_write_value(struct i2c_client *client, u8 register,
+                           u8 value);
+static void fscpos_update_client(struct i2c_client *client);
+static void fscpos_init_client(struct i2c_client *client);
+
+
+static void fscpos_in(struct i2c_client *client, int operation, int ctl_name,
+                       int *nrels_mag, long *results);
+static void fscpos_fan(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void fscpos_fan_internal(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results, 
+                       int nr, int reg_state, int reg_min, int res_ripple);
+static void fscpos_temp(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void fscpos_volt(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void fscpos_wdog(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+
+static int fscpos_id = 0;
+
+static struct i2c_driver fscpos_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "FSCPOS sensor driver",
+       .id             = I2C_DRIVERID_FSCPOS,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = fscpos_attach_adapter,
+       .detach_client  = fscpos_detach_client,
+};
+
+/* -- SENSORS SYSCTL START -- */
+#define FSCPOS_SYSCTL_VOLT0    1000       /* 12 volt supply */
+#define FSCPOS_SYSCTL_VOLT1    1001       /* 5 volt supply */
+#define FSCPOS_SYSCTL_VOLT2    1002       /* batterie voltage*/
+#define FSCPOS_SYSCTL_FAN0     1101       /* state, min, ripple, actual value fan 0 */
+#define FSCPOS_SYSCTL_FAN1     1102       /* state, min, ripple, actual value fan 1 */
+#define FSCPOS_SYSCTL_FAN2     1103       /* state, min, ripple, actual value fan 2 */
+#define FSCPOS_SYSCTL_TEMP0    1201       /* state and value of sensor 0, cpu die */
+#define FSCPOS_SYSCTL_TEMP1    1202       /* state and value of sensor 1, motherboard */
+#define FSCPOS_SYSCTL_TEMP2    1203       /* state and value of sensor 2, chassis */
+#define FSCPOS_SYSCTL_REV     2000        /* Revision */
+#define FSCPOS_SYSCTL_EVENT   2001        /* global event status */
+#define FSCPOS_SYSCTL_CONTROL 2002        /* global control byte */
+#define FSCPOS_SYSCTL_WDOG     2003       /* state, min, ripple, actual value fan 2 */
+/* -- SENSORS SYSCTL END -- */
+
+/* These files are created for each detected FSCPOS. This is just a template;
+   though at first sight, you might think we could use a statically
+   allocated list, we need some way to get back to the parent - which
+   is done through one of the 'extra' fields which are initialized 
+   when a new copy is allocated. */
+static ctl_table fscpos_dir_table_template[] = {
+       {FSCPOS_SYSCTL_REV, "rev", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &fscpos_in},
+       {FSCPOS_SYSCTL_EVENT, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &fscpos_in},
+       {FSCPOS_SYSCTL_CONTROL, "control", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &fscpos_in},
+       {FSCPOS_SYSCTL_TEMP0, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &fscpos_temp},
+       {FSCPOS_SYSCTL_TEMP1, "temp2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &fscpos_temp},
+       {FSCPOS_SYSCTL_TEMP2, "temp3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &fscpos_temp},
+       {FSCPOS_SYSCTL_VOLT0, "in0", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &fscpos_volt},
+       {FSCPOS_SYSCTL_VOLT1, "in1", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &fscpos_volt},
+       {FSCPOS_SYSCTL_VOLT2, "in2", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &fscpos_volt},
+       {FSCPOS_SYSCTL_FAN0, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &fscpos_fan},
+       {FSCPOS_SYSCTL_FAN1, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &fscpos_fan},
+       {FSCPOS_SYSCTL_FAN2, "fan3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &fscpos_fan},
+       {FSCPOS_SYSCTL_WDOG, "wdog", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &fscpos_wdog},
+       {0}
+};
+
+static int fscpos_attach_adapter(struct i2c_adapter *adapter)
+{
+       return i2c_detect(adapter, &addr_data, fscpos_detect);
+}
+
+int fscpos_detect(struct i2c_adapter *adapter, int address,
+               unsigned short flags, int kind)
+{
+       int i;
+       struct i2c_client *new_client;
+       struct fscpos_data *data;
+       int err = 0;
+       const char *type_name, *client_name;
+
+       /* Make sure we aren't probing the ISA bus!! This is just a safety check
+          at this moment; i2c_detect really won't call us. */
+#ifdef DEBUG
+       if (i2c_is_isa_adapter(adapter)) {
+               printk
+                   ("fscpos.o: fscpos_detect called for an ISA bus adapter?!?\n");
+               return 0;
+       }
+#endif
+
+       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
+               goto ERROR0;
+
+       /* OK. For now, we presume we have a valid client. We now create the
+          client structure, even though we cannot fill it completely yet.
+          But it allows us to access fscpos_{read,write}_value. */
+       if (!(data = kmalloc(sizeof(struct fscpos_data), GFP_KERNEL))) {
+               err = -ENOMEM;
+               goto ERROR0;
+       }
+
+       new_client = &data->client;
+       new_client->addr = address;
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &fscpos_driver;
+       new_client->flags = 0;
+
+       /* Do the remaining detection unless force or force_fscpos parameter */
+       if (kind < 0) {
+               if (fscpos_read_value(new_client, FSCPOS_REG_IDENT_0) != 0x50)
+                       goto ERROR1;
+               if (fscpos_read_value(new_client, FSCPOS_REG_IDENT_1) != 0x45)
+                       goto ERROR1;
+               if (fscpos_read_value(new_client, FSCPOS_REG_IDENT_2) != 0x47)
+                       goto ERROR1;
+       }
+
+       kind = fscpos;
+
+       type_name = "fscpos";
+       client_name = "fsc poseidon chip";
+
+       /* Fill in the remaining client fields and put it into the global list */
+       strcpy(new_client->name, client_name);
+
+       new_client->id = fscpos_id++;
+       data->valid = 0;
+       init_MUTEX(&data->update_lock);
+
+       /* Tell the I2C layer a new client has arrived */
+       if ((err = i2c_attach_client(new_client)))
+               goto ERROR3;
+
+       /* Register a new directory entry with module sensors */
+       if ((i = i2c_register_entry(new_client, type_name,
+                                       fscpos_dir_table_template)) < 0) {
+               err = i;
+               goto ERROR4;
+       }
+       data->sysctl_id = i;
+
+       fscpos_init_client(new_client);
+       return 0;
+
+/* OK, this is not exactly good programming practice, usually. But it is
+   very code-efficient in this case. */
+      ERROR4:
+       i2c_detach_client(new_client);
+      ERROR3:
+      ERROR1:
+       kfree(data);
+      ERROR0:
+       return err;
+}
+
+static int fscpos_detach_client(struct i2c_client *client)
+{
+       int err;
+
+       i2c_deregister_entry(((struct fscpos_data *) (client->data))->
+                                sysctl_id);
+
+       if ((err = i2c_detach_client(client))) {
+               printk
+                   ("fscpos.o: Client deregistration failed, client not detached.\n");
+               return err;
+       }
+
+       kfree(client->data);
+
+       return 0;
+}
+
+static int fscpos_read_value(struct i2c_client *client, u8 reg)
+{
+#ifdef DEBUG
+       printk("fscpos: read reg 0x%02x\n",reg);
+#endif
+       return i2c_smbus_read_byte_data(client, reg);
+}
+
+static int fscpos_write_value(struct i2c_client *client, u8 reg, u8 value)
+{
+#ifdef DEBUG
+       printk("fscpos: write reg 0x%02x, val 0x%02x\n",reg, value);
+#endif
+       return i2c_smbus_write_byte_data(client, reg, value);
+}
+
+/* Called when we have found a new FSCPOS. It should set limits, etc. */
+static void fscpos_init_client(struct i2c_client *client)
+{
+       struct fscpos_data *data = client->data;
+
+       /* read revision from chip */
+       data->revision =  fscpos_read_value(client,FSCPOS_REG_REVISION);
+       /* setup missing fan2_min value */
+       data->fan_min[2] = 0xff;
+}
+
+static void fscpos_update_client(struct i2c_client *client)
+{
+       struct fscpos_data *data = client->data;
+
+       down(&data->update_lock);
+
+       if ((jiffies - data->last_updated > 2 * HZ) ||
+           (jiffies < data->last_updated) || !data->valid) {
+
+#ifdef DEBUG
+               printk("Starting fscpos update\n");
+#endif
+               data->temp_act[0] = fscpos_read_value(client, FSCPOS_REG_TEMP0_ACT);
+               data->temp_act[1] = fscpos_read_value(client, FSCPOS_REG_TEMP1_ACT);
+               data->temp_act[2] = fscpos_read_value(client, FSCPOS_REG_TEMP2_ACT);
+               data->temp_status[0] = fscpos_read_value(client, FSCPOS_REG_TEMP0_STATE);
+               data->temp_status[1] = fscpos_read_value(client, FSCPOS_REG_TEMP1_STATE);
+               data->temp_status[2] = fscpos_read_value(client, FSCPOS_REG_TEMP2_STATE);
+
+               data->volt[0] = fscpos_read_value(client, FSCPOS_REG_VOLT_12);
+               data->volt[1] = fscpos_read_value(client, FSCPOS_REG_VOLT_5);
+               data->volt[2] = fscpos_read_value(client, FSCPOS_REG_VOLT_BATT);
+
+               data->fan_act[0] = fscpos_read_value(client, FSCPOS_REG_FAN0_ACT);
+               data->fan_act[1] = fscpos_read_value(client, FSCPOS_REG_FAN1_ACT);
+               data->fan_act[2] = fscpos_read_value(client, FSCPOS_REG_FAN2_ACT);
+               data->fan_status[0] = fscpos_read_value(client, FSCPOS_REG_FAN0_STATE);
+               data->fan_status[1] = fscpos_read_value(client, FSCPOS_REG_FAN1_STATE);
+               data->fan_status[2] = fscpos_read_value(client, FSCPOS_REG_FAN2_STATE);
+               data->fan_min[0] = fscpos_read_value(client, FSCPOS_REG_FAN0_MIN);
+               data->fan_min[1] = fscpos_read_value(client, FSCPOS_REG_FAN1_MIN);
+               /* fan2_min is not supported */
+               data->fan_ripple[0] = fscpos_read_value(client, FSCPOS_REG_FAN0_RIPPLE);
+               data->fan_ripple[1] = fscpos_read_value(client, FSCPOS_REG_FAN1_RIPPLE);
+               data->fan_ripple[2] = fscpos_read_value(client, FSCPOS_REG_FAN2_RIPPLE);
+
+               data->watchdog[0] = fscpos_read_value(client, FSCPOS_REG_WDOG_PRESET);
+               data->watchdog[1] = fscpos_read_value(client, FSCPOS_REG_WDOG_STATE);
+               data->watchdog[2] = fscpos_read_value(client, FSCPOS_REG_WDOG_CONTROL);
+
+               data->global_event = fscpos_read_value(client, FSCPOS_REG_EVENT_STATE);
+
+                data->last_updated = jiffies;
+                data->valid = 1;                 
+       }
+
+       up(&data->update_lock);
+}
+
+
+/* The next few functions are the call-back functions of the /proc/sys and
+   sysctl files. Which function is used is defined in the ctl_table in
+   the extra1 field.
+   Each function must return the magnitude (power of 10 to divide the date
+   with) if it is called with operation==SENSORS_PROC_REAL_INFO. It must
+   put a maximum of *nrels elements in results reflecting the data of this
+   file, and set *nrels to the number it actually put in it, if operation==
+   SENSORS_PROC_REAL_READ. Finally, it must get upto *nrels elements from
+   results and write them to the chip, if operations==SENSORS_PROC_REAL_WRITE.
+   Note that on SENSORS_PROC_REAL_READ, I do not check whether results is
+   large enough (by checking the incoming value of *nrels). This is not very
+   good practice, but as long as you put less than about 5 values in results,
+   you can assume it is large enough. */
+void fscpos_in(struct i2c_client *client, int operation, int ctl_name,
+            int *nrels_mag, long *results)
+{
+       struct fscpos_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               fscpos_update_client(client);
+               switch(ctl_name) {
+                       case FSCPOS_SYSCTL_REV:
+                               results[0] = data->revision ;
+                               break;
+                       case FSCPOS_SYSCTL_EVENT:
+                               results[0] = data->global_event & 0x1f;
+                               break;
+                       case FSCPOS_SYSCTL_CONTROL:
+                               results[0] = data->global_control & 0x01;
+                               break;
+                       default:
+                               printk("fscpos: ctl_name %d not supported\n",
+                                       ctl_name);
+                               *nrels_mag = 0;
+                               return;
+               }
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if((ctl_name == FSCPOS_SYSCTL_CONTROL) && (*nrels_mag >= 1)) {
+                       data->global_control = (results[0] & 0x01);
+                       printk("fscpos: writing 0x%02x to global_control\n",
+                               data->global_control);
+                       fscpos_write_value(client,FSCPOS_REG_CONTROL,
+                               data->global_control);
+               }
+               else
+                       printk("fscpos: writing to chip not supported\n");
+       }
+}
+
+#define TEMP_FROM_REG(val)    (val-128)
+
+
+void fscpos_temp(struct i2c_client *client, int operation, int ctl_name,
+              int *nrels_mag, long *results)
+{
+       struct fscpos_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               fscpos_update_client(client);
+               switch(ctl_name) {
+                       case FSCPOS_SYSCTL_TEMP0:
+                               results[0] = data->temp_status[0] & 0x03;
+                               results[1] = TEMP_FROM_REG(data->temp_act[0]);
+                               break;
+                       case FSCPOS_SYSCTL_TEMP1:
+                               results[0] = data->temp_status[1] & 0x03;
+                               results[1] = TEMP_FROM_REG(data->temp_act[1]);
+                               break;
+                       case FSCPOS_SYSCTL_TEMP2:
+                               results[0] = data->temp_status[2] & 0x03;
+                               results[1] = TEMP_FROM_REG(data->temp_act[2]);
+                               break;
+                       default:
+                               printk("fscpos: ctl_name %d not supported\n",
+                                       ctl_name);
+                               *nrels_mag = 0;
+                               return;
+               }
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if(*nrels_mag >= 1) {
+                       switch(ctl_name) {
+                               case FSCPOS_SYSCTL_TEMP0:
+                                       data->temp_status[0] = 
+                                               (data->temp_status[0] & ~0x02) 
+                                               | (results[0] & 0x02);
+                                       printk("fscpos: writing value 0x%02x "
+                                               "to temp0_status\n",
+                                               data->temp_status[0]);
+                                       fscpos_write_value(client,
+                                               FSCPOS_REG_TEMP0_STATE,
+                                               data->temp_status[0] & 0x02);
+                                       break;
+                               case FSCPOS_SYSCTL_TEMP1:
+                                       data->temp_status[1] = (data->temp_status[1] & ~0x02) | (results[0] & 0x02);
+                                       printk("fscpos: writing value 0x%02x to temp1_status\n", data->temp_status[1]);
+                                       fscpos_write_value(client,FSCPOS_REG_TEMP1_STATE,
+                                               data->temp_status[1] & 0x02);
+                                       break;
+                               case FSCPOS_SYSCTL_TEMP2:
+                                       data->temp_status[2] = (data->temp_status[2] & ~0x02) | (results[0] & 0x02);
+                                       printk("fscpos: writing value 0x%02x to temp2_status\n", data->temp_status[2]);
+                                       fscpos_write_value(client,FSCPOS_REG_TEMP2_STATE,
+                                               data->temp_status[2] & 0x02);
+                                       break;
+                               default:
+                                       printk("fscpos: ctl_name %d not supported\n",ctl_name);
+                       }
+               }
+               else
+                       printk("fscpos: writing to chip not supported\n");
+       }
+}
+
+#define VOLT_FROM_REG(val,mult)    (val*mult/255)
+
+void fscpos_volt(struct i2c_client *client, int operation, int ctl_name,
+              int *nrels_mag, long *results)
+{
+       struct fscpos_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 2;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               fscpos_update_client(client);
+               switch(ctl_name) {
+                       case FSCPOS_SYSCTL_VOLT0:
+                               results[0] = VOLT_FROM_REG(data->volt[0],1420);
+                               break;
+                       case FSCPOS_SYSCTL_VOLT1:
+                               results[0] = VOLT_FROM_REG(data->volt[1],660);
+                               break;
+                       case FSCPOS_SYSCTL_VOLT2:
+                               results[0] = VOLT_FROM_REG(data->volt[2],330);
+                               break;
+                       default:
+                               printk("fscpos: ctl_name %d not supported\n",
+                                       ctl_name);
+                               *nrels_mag = 0;
+                               return;
+               }
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+                       printk("fscpos: writing to chip not supported\n");
+       }
+}
+
+void fscpos_fan(struct i2c_client *client, int operation, int ctl_name,
+              int *nrels_mag, long *results)
+{
+
+       switch(ctl_name) {
+               case FSCPOS_SYSCTL_FAN0:
+                       fscpos_fan_internal(client,operation,ctl_name,nrels_mag,results,
+                               0,FSCPOS_REG_FAN0_STATE,FSCPOS_REG_FAN0_MIN,
+                               FSCPOS_REG_FAN0_RIPPLE);
+                       break;
+               case FSCPOS_SYSCTL_FAN1:
+                       fscpos_fan_internal(client,operation,ctl_name,nrels_mag,results,
+                               1,FSCPOS_REG_FAN1_STATE,FSCPOS_REG_FAN1_MIN,
+                               FSCPOS_REG_FAN1_RIPPLE);
+                       break;
+               case FSCPOS_SYSCTL_FAN2:
+                       fscpos_fan_internal(client,operation,ctl_name,nrels_mag,results,
+                               2,FSCPOS_REG_FAN2_STATE,0xff,
+                               FSCPOS_REG_FAN2_RIPPLE);
+                       break;
+               default:
+                       printk("fscpos: illegal fan nr %d\n",ctl_name);
+       }
+}
+                       
+#define RPM_FROM_REG(val)   (val*60)
+
+void fscpos_fan_internal(struct i2c_client *client, int operation, int ctl_name,
+              int *nrels_mag, long *results, int nr,
+              int reg_state, int reg_min, int reg_ripple )
+{
+       struct fscpos_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               fscpos_update_client(client);
+               results[0] = data->fan_status[nr] & 0x04;
+               results[1] = data->fan_min[nr];
+               results[2] = data->fan_ripple[nr] & 0x03;
+               results[3] = RPM_FROM_REG(data->fan_act[nr]);
+               *nrels_mag = 4;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if(*nrels_mag >= 1) {
+                       data->fan_status[nr] = results[0] & 0x04;
+                       printk("fscpos: writing value 0x%02x to fan%d_status\n",
+                               data->fan_status[nr],nr);
+                       fscpos_write_value(client,reg_state,
+                               data->fan_status[nr]);
+               }
+               if((*nrels_mag >= 2) && (nr < 2)) {  
+                       /* minimal speed for fan2 not supported */
+                       data->fan_min[nr] = results[1];
+                       printk("fscpos: writing value 0x%02x to fan%d_min\n",
+                               data->fan_min[nr],nr);
+                       fscpos_write_value(client,reg_min,
+                               data->fan_min[nr]);
+               }
+               if(*nrels_mag >= 3) {
+                       if((results[2] & 0x03) == 0) {
+                               printk("fscpos: fan%d ripple 0 not allowed\n",nr);
+                               return;
+                       }
+                       data->fan_ripple[nr] = results[2] & 0x03;
+                       printk("fscpos: writing value 0x%02x to fan%d_ripple\n",
+                               data->fan_ripple[nr],nr);
+                       fscpos_write_value(client,reg_ripple,
+                               data->fan_ripple[nr]);
+               }       
+       }
+}
+
+void fscpos_wdog(struct i2c_client *client, int operation, int ctl_name,
+            int *nrels_mag, long *results)
+{
+       struct fscpos_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               fscpos_update_client(client);
+               results[0] = data->watchdog[0] ;
+               results[1] = data->watchdog[1] & 0x02;
+               results[2] = data->watchdog[2] & 0xb0;
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->watchdog[0] = results[0] & 0xff;
+                       printk("fscpos: writing value 0x%02x to wdog_preset\n",
+                               data->watchdog[0]); 
+                       fscpos_write_value(client,FSCPOS_REG_WDOG_PRESET,
+                               data->watchdog[0]);
+               } 
+               if (*nrels_mag >= 2) {
+                       data->watchdog[1] = results[1] & 0x02;
+                       printk("fscpos: writing value 0x%02x to wdog_state\n",
+                               data->watchdog[1]); 
+                       fscpos_write_value(client,FSCPOS_REG_WDOG_STATE,
+                               data->watchdog[1]);
+               }
+               if (*nrels_mag >= 3) {
+                       data->watchdog[2] = results[2] & 0xb0;
+                       printk("fscpos: writing value 0x%02x to wdog_control\n",
+                               data->watchdog[2]); 
+                       fscpos_write_value(client,FSCPOS_REG_WDOG_CONTROL,
+                               data->watchdog[2]);
+               }
+       }
+}
+
+static int __init sm_fscpos_init(void)
+{
+       printk("fscpos.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       return i2c_add_driver(&fscpos_driver);
+}
+
+static void __exit sm_fscpos_exit(void)
+{
+       i2c_del_driver(&fscpos_driver);
+}
+
+
+
+MODULE_AUTHOR
+    ("Hermann Jung <hej@odn.de> based on work from Frodo Looijaard <frodol@dds.nl> and Philip Edelbrock <phil@netroedge.com>");
+MODULE_DESCRIPTION("fujitsu siemens poseidon chip driver");
+MODULE_LICENSE("GPL");
+
+module_init(sm_fscpos_init);
+module_exit(sm_fscpos_exit);
--- linux-old/drivers/sensors/fscscy.c  Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/fscscy.c      Mon Dec 13 20:18:46 2004
@@ -0,0 +1,915 @@
+/*
+    fscscy.c - Part of lm_sensors, Linux kernel modules for hardware
+             monitoring
+    Copyright (c) 2001 Martin Knoblauch <mkn@teraport.de, knobi@knobisoft.de>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/* 
+    fujitsu siemens scylla chip, 
+    module based on lm80.c, fscpos.c
+    Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl>
+    and Philip Edelbrock <phil@netroedge.com>
+*/
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+MODULE_LICENSE("GPL");
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = { 0x73, SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { SENSORS_I2C_END };
+static unsigned int normal_isa[] = { SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+/* Insmod parameters */
+SENSORS_INSMOD_1(fscscy);
+
+/* The FSCSCY registers */
+
+/* chip identification */
+#define FSCSCY_REG_IDENT_0    0x00
+#define FSCSCY_REG_IDENT_1    0x01
+#define FSCSCY_REG_IDENT_2    0x02
+#define FSCSCY_REG_REVISION   0x03
+
+/* global control and status */
+#define FSCSCY_REG_EVENT_STATE  0x04
+#define FSCSCY_REG_CONTROL       0x05
+
+/* watchdog */
+#define FSCSCY_REG_WDOG_PRESET      0x28
+#define FSCSCY_REG_WDOG_STATE       0x23
+#define FSCSCY_REG_WDOG_CONTROL     0x21
+
+/*
+** Fan definitions
+**
+** _RPMMIN: Minimum speed. Can be set via interface, but only for three of the fans
+**          FAN1_RPMMIN is wired to Fan 0 (CPU Fans)
+**          FAN4_RPMMIN is wired to Fan 2 (PS Fans ??)
+**          FAN5_RPMMIN is wired to Fan 3 (AUX Fans ??)
+** _ACT:    Actual Fan Speed
+** _STATE:  Fan status register
+** _RIPPLE: Fan speed multiplier
+*/
+
+/* fan 0  */
+#define FSCSCY_REG_FAN0_RPMMIN 0x65
+#define FSCSCY_REG_FAN0_ACT    0x6b
+#define FSCSCY_REG_FAN0_STATE  0x62
+#define FSCSCY_REG_FAN0_RIPPLE 0x6f
+
+/* fan 1  */
+#define FSCSCY_REG_FAN1_RPMMIN     FSCSCY_REG_FAN0_RPMMIN
+#define FSCSCY_REG_FAN1_ACT     0x6c
+#define FSCSCY_REG_FAN1_STATE   0x61
+#define FSCSCY_REG_FAN1_RIPPLE  0x6f
+
+/* fan 2  */
+#define FSCSCY_REG_FAN2_RPMMIN     0x55
+#define FSCSCY_REG_FAN2_ACT     0x0e
+#define FSCSCY_REG_FAN2_STATE   0x0d
+#define FSCSCY_REG_FAN2_RIPPLE  0x0f
+
+/* fan 3  */
+#define FSCSCY_REG_FAN3_RPMMIN     0xa5
+#define FSCSCY_REG_FAN3_ACT     0xab
+#define FSCSCY_REG_FAN3_STATE   0xa2
+#define FSCSCY_REG_FAN3_RIPPLE  0xaf
+
+/* fan 4  */
+#define FSCSCY_REG_FAN4_RPMMIN     FSCSCY_REG_FAN2_RPMMIN
+#define FSCSCY_REG_FAN4_ACT    0x5c
+#define FSCSCY_REG_FAN4_STATE   0x52
+#define FSCSCY_REG_FAN4_RIPPLE  0x0f
+
+/* fan 5  */
+#define FSCSCY_REG_FAN5_RPMMIN     FSCSCY_REG_FAN3_RPMMIN
+#define FSCSCY_REG_FAN5_ACT     0xbb
+#define FSCSCY_REG_FAN5_STATE   0xb2
+#define FSCSCY_REG_FAN5_RIPPLE  0xbf
+
+/* voltage supervision */
+#define FSCSCY_REG_VOLT_12       0x45
+#define FSCSCY_REG_VOLT_5        0x42
+#define FSCSCY_REG_VOLT_BATT     0x48
+
+/* temperatures */
+/* sensor 0 */
+#define FSCSCY_REG_TEMP0_ACT   0x64
+#define FSCSCY_REG_TEMP0_STATE 0x71
+#define FSCSCY_REG_TEMP0_LIM   0x76
+
+/* sensor 1 */
+#define FSCSCY_REG_TEMP1_ACT   0xD0
+#define FSCSCY_REG_TEMP1_STATE 0xD1
+#define FSCSCY_REG_TEMP1_LIM   0xD6
+
+/* sensor 2 */
+#define FSCSCY_REG_TEMP2_ACT   0x32
+#define FSCSCY_REG_TEMP2_STATE 0x81
+#define FSCSCY_REG_TEMP2_LIM   0x86
+
+/* sensor3 */
+#define FSCSCY_REG_TEMP3_ACT   0x35
+#define FSCSCY_REG_TEMP3_STATE 0x91
+#define FSCSCY_REG_TEMP3_LIM   0x96
+
+/* PCI Load */
+#define FSCSCY_REG_PCILOAD     0x1a
+
+/* Intrusion Sensor */
+#define FSCSCY_REG_INTR_STATE  0x13
+#define FSCSCY_REG_INTR_CTRL   0x12
+
+/* Conversions. Rounding and limit checking is only done on the TO_REG
+   variants. Note that you should be a bit careful with which arguments
+   these macros are called: arguments may be evaluated more than once.
+   Fixing this is just not worth it. */
+
+#define IN_TO_REG(val,nr) (SENSORS_LIMIT((val),0,255))
+#define IN_FROM_REG(val,nr) (val)
+
+/* Initial limits */
+
+/* For each registered FSCSCY, we need to keep some data in memory. That
+   data is pointed to by fscscy_list[NR]->data. The structure itself is
+   dynamically allocated, at the same time when a new fscscy client is
+   allocated. */
+struct fscscy_data {
+       struct i2c_client client;
+       int sysctl_id;
+
+       struct semaphore update_lock;
+       char valid;             /* !=0 if following fields are valid */
+       unsigned long last_updated;     /* In jiffies */
+
+       u8  revision;        /* revision of chip */
+       u8  global_event;    /* global event status */
+       u8  global_control;  /* global control register */
+       u8  watchdog[3];     /* watchdog */
+       u8  volt[3];         /* 12, 5, battery current */ 
+       u8  volt_min[3];     /* minimum voltages over module "lifetime" */
+       u8  volt_max[3];     /* maximum voltages over module "lifetime" */
+       u8  temp_act[4];     /* temperature */
+       u8  temp_status[4];  /* status of temp. sensor */
+       u8  temp_lim[4];     /* limit temperature of temp. sensor */
+       u8  temp_min[4];     /* minimum of temp. sensor, this is just calculated by the module */
+       u8  temp_max[4];     /* maximum of temp. sensor, this is just calculsted by the module */
+       u8  fan_act[6];      /* fans revolutions per second */
+       u8  fan_status[6];   /* fan status */
+       u8  fan_rpmmin[6];   /* fan min value for rps */
+       u8  fan_ripple[6];   /* divider for rps */
+       u8  fan_min[6];      /* minimum RPM over module "lifetime" */
+       u8  fan_max[6];      /* maximum RPM over module "lifetime" */
+       u8  pciload;         /* PCILoad value */
+       u8  intr_status;     /* Intrusion Status */
+       u8  intr_control;    /* Intrusion Control */
+};
+
+
+static int fscscy_attach_adapter(struct i2c_adapter *adapter);
+static int fscscy_detect(struct i2c_adapter *adapter, int address,
+                      unsigned short flags, int kind);
+static int fscscy_detach_client(struct i2c_client *client);
+
+static int fscscy_read_value(struct i2c_client *client, u8 register);
+static int fscscy_write_value(struct i2c_client *client, u8 register,
+                           u8 value);
+static void fscscy_update_client(struct i2c_client *client);
+static void fscscy_init_client(struct i2c_client *client);
+
+
+static void fscscy_in(struct i2c_client *client, int operation, int ctl_name,
+                       int *nrels_mag, long *results);
+static void fscscy_fan(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void fscscy_fan_internal(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results, 
+                       int nr, int reg_state, int reg_min, int res_ripple);
+static void fscscy_temp(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void fscscy_volt(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void fscscy_wdog(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void fscscy_pciload(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void fscscy_intrusion(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+
+static int fscscy_id = 0;
+
+static struct i2c_driver fscscy_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "FSCSCY sensor driver",
+       .id             = I2C_DRIVERID_FSCSCY,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = fscscy_attach_adapter,
+       .detach_client  = fscscy_detach_client,
+};
+
+/* The /proc/sys entries */
+
+/* -- SENSORS SYSCTL START -- */
+#define FSCSCY_SYSCTL_VOLT0    1000       /* 12 volt supply */
+#define FSCSCY_SYSCTL_VOLT1    1001       /* 5 volt supply */
+#define FSCSCY_SYSCTL_VOLT2    1002       /* batterie voltage*/
+#define FSCSCY_SYSCTL_FAN0     1101       /* state, min, ripple, actual value fan 0 */
+#define FSCSCY_SYSCTL_FAN1     1102       /* state, min, ripple, actual value fan 1 */
+#define FSCSCY_SYSCTL_FAN2     1103       /* state, min, ripple, actual value fan 2 */
+#define FSCSCY_SYSCTL_FAN3     1104       /* state, min, ripple, actual value fan 3 */
+#define FSCSCY_SYSCTL_FAN4     1105       /* state, min, ripple, actual value fan 4 */
+#define FSCSCY_SYSCTL_FAN5     1106       /* state, min, ripple, actual value fan 5 */
+#define FSCSCY_SYSCTL_TEMP0    1201       /* state and value of sensor 0, cpu die */
+#define FSCSCY_SYSCTL_TEMP1    1202       /* state and value of sensor 1, motherboard */
+#define FSCSCY_SYSCTL_TEMP2    1203       /* state and value of sensor 2, chassis */
+#define FSCSCY_SYSCTL_TEMP3    1204       /* state and value of sensor 3, chassis */
+#define FSCSCY_SYSCTL_REV     2000        /* Revision */
+#define FSCSCY_SYSCTL_EVENT   2001        /* global event status */
+#define FSCSCY_SYSCTL_CONTROL 2002        /* global control byte */
+#define FSCSCY_SYSCTL_WDOG     2003       /* state, min, ripple, actual value fan 2 */
+#define FSCSCY_SYSCTL_PCILOAD  2004       /* PCILoad value */
+#define FSCSCY_SYSCTL_INTRUSION 2005      /* state, control for intrusion sensor */
+
+/* -- SENSORS SYSCTL END -- */
+
+/* These files are created for each detected FSCSCY. This is just a template;
+   though at first sight, you might think we could use a statically
+   allocated list, we need some way to get back to the parent - which
+   is done through one of the 'extra' fields which are initialized 
+   when a new copy is allocated. */
+static ctl_table fscscy_dir_table_template[] = {
+       {FSCSCY_SYSCTL_REV, "rev", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &fscscy_in},
+       {FSCSCY_SYSCTL_EVENT, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &fscscy_in},
+       {FSCSCY_SYSCTL_CONTROL, "control", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &fscscy_in},
+       {FSCSCY_SYSCTL_TEMP0, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &fscscy_temp},
+       {FSCSCY_SYSCTL_TEMP1, "temp2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &fscscy_temp},
+       {FSCSCY_SYSCTL_TEMP2, "temp3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &fscscy_temp},
+       {FSCSCY_SYSCTL_TEMP3, "temp4", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &fscscy_temp},
+       {FSCSCY_SYSCTL_VOLT0, "in0", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &fscscy_volt},
+       {FSCSCY_SYSCTL_VOLT1, "in1", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &fscscy_volt},
+       {FSCSCY_SYSCTL_VOLT2, "in2", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &fscscy_volt},
+       {FSCSCY_SYSCTL_FAN0, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &fscscy_fan},
+       {FSCSCY_SYSCTL_FAN1, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &fscscy_fan},
+       {FSCSCY_SYSCTL_FAN2, "fan3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &fscscy_fan},
+       {FSCSCY_SYSCTL_FAN3, "fan4", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &fscscy_fan},
+       {FSCSCY_SYSCTL_FAN4, "fan5", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &fscscy_fan},
+       {FSCSCY_SYSCTL_FAN5, "fan6", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &fscscy_fan},
+       {FSCSCY_SYSCTL_WDOG, "wdog", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &fscscy_wdog},
+       {FSCSCY_SYSCTL_PCILOAD, "pciload", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &fscscy_pciload},
+       {FSCSCY_SYSCTL_INTRUSION, "intrusion", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &fscscy_intrusion},
+       {0}
+};
+
+static int fscscy_attach_adapter(struct i2c_adapter *adapter)
+{
+       return i2c_detect(adapter, &addr_data, fscscy_detect);
+}
+
+int fscscy_detect(struct i2c_adapter *adapter, int address,
+               unsigned short flags, int kind)
+{
+       int i;
+       struct i2c_client *new_client;
+       struct fscscy_data *data;
+       int err = 0;
+       const char *type_name, *client_name;
+
+       /* Make sure we aren't probing the ISA bus!! This is just a safety check
+          at this moment; i2c_detect really won't call us. */
+#ifdef DEBUG
+       if (i2c_is_isa_adapter(adapter)) {
+               printk
+                   ("fscscy.o: fscscy_detect called for an ISA bus adapter?!?\n");
+               return 0;
+       }
+#endif
+
+       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
+               goto ERROR0;
+
+       /* OK. For now, we presume we have a valid client. We now create the
+          client structure, even though we cannot fill it completely yet.
+          But it allows us to access fscscy_{read,write}_value. */
+       if (!(data = kmalloc(sizeof(struct fscscy_data), GFP_KERNEL))) {
+               err = -ENOMEM;
+               goto ERROR0;
+       }
+
+       new_client = &data->client;
+       new_client->addr = address;
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &fscscy_driver;
+       new_client->flags = 0;
+
+       /* Do the remaining detection unless force or force_fscscy parameter */
+       if (kind < 0) {
+               if (fscscy_read_value(new_client, FSCSCY_REG_IDENT_0) != 0x53)
+                       goto ERROR1;
+               if (fscscy_read_value(new_client, FSCSCY_REG_IDENT_1) != 0x43)
+                       goto ERROR1;
+               if (fscscy_read_value(new_client, FSCSCY_REG_IDENT_2) != 0x59)
+                       goto ERROR1;
+       }
+
+       kind = fscscy;
+
+       type_name = "fscscy";
+       client_name = "fsc scylla chip";
+
+       /* Fill in the remaining client fields and put it into the global list */
+       strcpy(new_client->name, client_name);
+
+       new_client->id = fscscy_id++;
+       data->valid = 0;
+       init_MUTEX(&data->update_lock);
+
+       /* Tell the I2C layer a new client has arrived */
+       if ((err = i2c_attach_client(new_client)))
+               goto ERROR3;
+
+       /* Register a new directory entry with module sensors */
+       if ((i = i2c_register_entry(new_client, type_name,
+                                       fscscy_dir_table_template)) < 0) {
+               err = i;
+               goto ERROR4;
+       }
+       data->sysctl_id = i;
+
+       fscscy_init_client(new_client);
+       return 0;
+
+/* OK, this is not exactly good programming practice, usually. But it is
+   very code-efficient in this case. */
+      ERROR4:
+       i2c_detach_client(new_client);
+      ERROR3:
+      ERROR1:
+       kfree(data);
+      ERROR0:
+       return err;
+}
+
+static int fscscy_detach_client(struct i2c_client *client)
+{
+       int err;
+
+       i2c_deregister_entry(((struct fscscy_data *) (client->data))->
+                                sysctl_id);
+
+       if ((err = i2c_detach_client(client))) {
+               printk
+                   ("fscscy.o: Client deregistration failed, client not detached.\n");
+               return err;
+       }
+
+       kfree(client->data);
+
+       return 0;
+}
+
+static int fscscy_read_value(struct i2c_client *client, u8 reg)
+{
+#ifdef DEBUG
+       printk("fscscy: read reg 0x%02x\n",reg);
+#endif
+       return i2c_smbus_read_byte_data(client, reg);
+}
+
+static int fscscy_write_value(struct i2c_client *client, u8 reg, u8 value)
+{
+#ifdef DEBUG
+       printk("fscscy: write reg 0x%02x, val 0x%02x\n",reg, value);
+#endif
+       return i2c_smbus_write_byte_data(client, reg, value);
+}
+
+/* Called when we have found a new FSCSCY. It should set limits, etc. */
+static void fscscy_init_client(struct i2c_client *client)
+{
+       struct fscscy_data *data = client->data;
+
+       /* read revision from chip */
+       data->revision =  fscscy_read_value(client,FSCSCY_REG_REVISION);
+
+        /* Initialize min/max values from chip */
+       data->fan_min[0]  = data->fan_max[0]  = fscscy_read_value(client, FSCSCY_REG_FAN0_ACT);
+       data->fan_min[1]  = data->fan_max[1]  = fscscy_read_value(client, FSCSCY_REG_FAN1_ACT);
+       data->fan_min[2]  = data->fan_max[2]  = fscscy_read_value(client, FSCSCY_REG_FAN2_ACT);
+       data->fan_min[3]  = data->fan_max[3]  = fscscy_read_value(client, FSCSCY_REG_FAN3_ACT);
+       data->fan_min[4]  = data->fan_max[4]  = fscscy_read_value(client, FSCSCY_REG_FAN4_ACT);
+       data->fan_min[4]  = data->fan_max[5]  = fscscy_read_value(client, FSCSCY_REG_FAN5_ACT);
+        data->temp_min[0] = data->temp_max[0] = fscscy_read_value(client, FSCSCY_REG_TEMP0_ACT);
+        data->temp_min[1] = data->temp_max[1] = fscscy_read_value(client, FSCSCY_REG_TEMP1_ACT);
+        data->temp_min[2] = data->temp_max[2] = fscscy_read_value(client, FSCSCY_REG_TEMP2_ACT);
+        data->temp_min[3] = data->temp_max[3] = fscscy_read_value(client, FSCSCY_REG_TEMP3_ACT);
+       data->volt_min[0] = data->volt_max[0] = fscscy_read_value(client, FSCSCY_REG_VOLT_12);
+       data->volt_min[1] = data->volt_max[1] = fscscy_read_value(client, FSCSCY_REG_VOLT_5);
+       data->volt_min[2] = data->volt_max[2] = fscscy_read_value(client, FSCSCY_REG_VOLT_BATT);
+}
+
+static void fscscy_update_client(struct i2c_client *client)
+{
+       struct fscscy_data *data = client->data;
+
+       down(&data->update_lock);
+
+       if ((jiffies - data->last_updated > 2 * HZ) ||
+           (jiffies < data->last_updated) || !data->valid) {
+
+#ifdef DEBUG
+               printk("Starting fscscy update\n");
+#endif
+               data->temp_act[0] = fscscy_read_value(client, FSCSCY_REG_TEMP0_ACT);
+                 if (data->temp_min[0] > data->temp_act[0]) data->temp_min[0] = data->temp_act[0];
+                 if (data->temp_max[0] < data->temp_act[0]) data->temp_max[0] = data->temp_act[0];
+               data->temp_act[1] = fscscy_read_value(client, FSCSCY_REG_TEMP1_ACT);
+                 if (data->temp_min[1] > data->temp_act[1]) data->temp_min[1] = data->temp_act[1];
+                 if (data->temp_max[1] < data->temp_act[1]) data->temp_max[1] = data->temp_act[1];
+               data->temp_act[2] = fscscy_read_value(client, FSCSCY_REG_TEMP2_ACT);
+                 if (data->temp_min[2] > data->temp_act[2]) data->temp_min[2] = data->temp_act[2];
+                 if (data->temp_max[2] < data->temp_act[2]) data->temp_max[2] = data->temp_act[2];
+               data->temp_act[3] = fscscy_read_value(client, FSCSCY_REG_TEMP3_ACT);
+                 if (data->temp_min[3] > data->temp_act[3]) data->temp_min[3] = data->temp_act[3];
+                 if (data->temp_max[3] < data->temp_act[3]) data->temp_max[3] = data->temp_act[3];
+               data->temp_status[0] = fscscy_read_value(client, FSCSCY_REG_TEMP0_STATE);
+               data->temp_status[1] = fscscy_read_value(client, FSCSCY_REG_TEMP1_STATE);
+               data->temp_status[2] = fscscy_read_value(client, FSCSCY_REG_TEMP2_STATE);
+               data->temp_status[3] = fscscy_read_value(client, FSCSCY_REG_TEMP3_STATE);
+               data->temp_lim[0] = fscscy_read_value(client, FSCSCY_REG_TEMP0_LIM);
+               data->temp_lim[1] = fscscy_read_value(client, FSCSCY_REG_TEMP1_LIM);
+               data->temp_lim[2] = fscscy_read_value(client, FSCSCY_REG_TEMP2_LIM);
+               data->temp_lim[3] = fscscy_read_value(client, FSCSCY_REG_TEMP3_LIM);
+
+               data->volt[0] = fscscy_read_value(client, FSCSCY_REG_VOLT_12);
+                 if (data->volt_min[0] > data->volt[0]) data->volt_min[0] = data->volt[0];
+                 if (data->volt_max[0] < data->volt[0]) data->volt_max[0] = data->volt[0];
+               data->volt[1] = fscscy_read_value(client, FSCSCY_REG_VOLT_5);
+                 if (data->volt_min[1] > data->volt[1]) data->volt_min[1] = data->volt[1];
+                 if (data->volt_max[1] < data->volt[1]) data->volt_max[1] = data->volt[1];
+               data->volt[2] = fscscy_read_value(client, FSCSCY_REG_VOLT_BATT);
+                 if (data->volt_min[2] > data->volt[2]) data->volt_min[2] = data->volt[2];
+                 if (data->volt_max[2] < data->volt[2]) data->volt_max[2] = data->volt[2];
+
+               data->fan_act[0] = fscscy_read_value(client, FSCSCY_REG_FAN0_ACT);
+                 if (data->fan_min[0] > data->fan_act[0]) data->fan_min[0] = data->fan_act[0];
+                 if (data->fan_max[0] < data->fan_act[0]) data->fan_max[0] = data->fan_act[0];
+               data->fan_act[1] = fscscy_read_value(client, FSCSCY_REG_FAN1_ACT);
+                 if (data->fan_min[1] > data->fan_act[1]) data->fan_min[1] = data->fan_act[1];
+                 if (data->fan_max[1] < data->fan_act[1]) data->fan_max[1] = data->fan_act[1];
+               data->fan_act[2] = fscscy_read_value(client, FSCSCY_REG_FAN2_ACT);
+                 if (data->fan_min[2] > data->fan_act[2]) data->fan_min[2] = data->fan_act[2];
+                 if (data->fan_max[2] < data->fan_act[2]) data->fan_max[2] = data->fan_act[2];
+               data->fan_act[3] = fscscy_read_value(client, FSCSCY_REG_FAN3_ACT);
+                 if (data->fan_min[3] > data->fan_act[3]) data->fan_min[3] = data->fan_act[3];
+                 if (data->fan_max[3] < data->fan_act[3]) data->fan_max[3] = data->fan_act[3];
+               data->fan_act[4] = fscscy_read_value(client, FSCSCY_REG_FAN4_ACT);
+                 if (data->fan_min[4] > data->fan_act[4]) data->fan_min[4] = data->fan_act[4];
+                 if (data->fan_max[4] < data->fan_act[4]) data->fan_max[4] = data->fan_act[4];
+               data->fan_act[5] = fscscy_read_value(client, FSCSCY_REG_FAN5_ACT);
+                 if (data->fan_min[5] > data->fan_act[5]) data->fan_min[5] = data->fan_act[5];
+                 if (data->fan_max[5] < data->fan_act[5]) data->fan_max[5] = data->fan_act[5];
+               data->fan_status[0] = fscscy_read_value(client, FSCSCY_REG_FAN0_STATE);
+               data->fan_status[1] = fscscy_read_value(client, FSCSCY_REG_FAN1_STATE);
+               data->fan_status[2] = fscscy_read_value(client, FSCSCY_REG_FAN2_STATE);
+               data->fan_status[3] = fscscy_read_value(client, FSCSCY_REG_FAN3_STATE);
+               data->fan_status[4] = fscscy_read_value(client, FSCSCY_REG_FAN4_STATE);
+               data->fan_status[5] = fscscy_read_value(client, FSCSCY_REG_FAN5_STATE);
+               data->fan_rpmmin[0] = fscscy_read_value(client, FSCSCY_REG_FAN0_RPMMIN);
+               data->fan_rpmmin[1] = fscscy_read_value(client, FSCSCY_REG_FAN1_RPMMIN);
+               data->fan_rpmmin[2] = fscscy_read_value(client, FSCSCY_REG_FAN2_RPMMIN);
+               data->fan_rpmmin[3] = fscscy_read_value(client, FSCSCY_REG_FAN3_RPMMIN);
+               data->fan_rpmmin[4] = fscscy_read_value(client, FSCSCY_REG_FAN4_RPMMIN);
+               data->fan_rpmmin[5] = fscscy_read_value(client, FSCSCY_REG_FAN5_RPMMIN);
+               data->fan_ripple[0] = fscscy_read_value(client, FSCSCY_REG_FAN0_RIPPLE);
+               data->fan_ripple[1] = fscscy_read_value(client, FSCSCY_REG_FAN1_RIPPLE);
+               data->fan_ripple[2] = fscscy_read_value(client, FSCSCY_REG_FAN2_RIPPLE);
+               data->fan_ripple[3] = fscscy_read_value(client, FSCSCY_REG_FAN3_RIPPLE);
+               data->fan_ripple[4] = fscscy_read_value(client, FSCSCY_REG_FAN4_RIPPLE);
+               data->fan_ripple[5] = fscscy_read_value(client, FSCSCY_REG_FAN5_RIPPLE);
+
+               data->watchdog[0] = fscscy_read_value(client, FSCSCY_REG_WDOG_PRESET);
+               data->watchdog[1] = fscscy_read_value(client, FSCSCY_REG_WDOG_STATE);
+               data->watchdog[2] = fscscy_read_value(client, FSCSCY_REG_WDOG_CONTROL);
+
+               data->global_event = fscscy_read_value(client, FSCSCY_REG_EVENT_STATE);
+               data->global_control = fscscy_read_value(client, FSCSCY_REG_CONTROL);
+               data->pciload = fscscy_read_value(client, FSCSCY_REG_PCILOAD);
+               data->intr_status = fscscy_read_value(client, FSCSCY_REG_INTR_STATE);
+               data->intr_control = fscscy_read_value(client, FSCSCY_REG_INTR_CTRL);
+
+                data->last_updated = jiffies;
+                data->valid = 1;                 
+       }
+
+       up(&data->update_lock);
+}
+
+
+/* The next few functions are the call-back functions of the /proc/sys and
+   sysctl files. Which function is used is defined in the ctl_table in
+   the extra1 field.
+   Each function must return the magnitude (power of 10 to divide the date
+   with) if it is called with operation==SENSORS_PROC_REAL_INFO. It must
+   put a maximum of *nrels elements in results reflecting the data of this
+   file, and set *nrels to the number it actually put in it, if operation==
+   SENSORS_PROC_REAL_READ. Finally, it must get upto *nrels elements from
+   results and write them to the chip, if operations==SENSORS_PROC_REAL_WRITE.
+   Note that on SENSORS_PROC_REAL_READ, I do not check whether results is
+   large enough (by checking the incoming value of *nrels). This is not very
+   good practice, but as long as you put less than about 5 values in results,
+   you can assume it is large enough. */
+void fscscy_in(struct i2c_client *client, int operation, int ctl_name,
+            int *nrels_mag, long *results)
+{
+       struct fscscy_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               fscscy_update_client(client);
+               switch(ctl_name) {
+                       case FSCSCY_SYSCTL_REV:
+                               results[0] = data->revision ;
+                               break;
+                       case FSCSCY_SYSCTL_EVENT:
+                               results[0] = data->global_event & 0x9f; /* MKN */
+                               break;
+                       case FSCSCY_SYSCTL_CONTROL:
+                               results[0] = data->global_control & 0x19; /* MKN */
+                               break;
+                       default:
+                               printk("fscscy: ctl_name %d not supported\n",
+                                       ctl_name);
+                               *nrels_mag = 0;
+                               return;
+               }
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if((ctl_name == FSCSCY_SYSCTL_CONTROL) && (*nrels_mag >= 1)) {
+                       data->global_control = (data->global_control & 0x18) | (results[0] & 0x01); /* MKN */
+                       printk("fscscy: writing 0x%02x to global_control\n",
+                               data->global_control);
+                       fscscy_write_value(client,FSCSCY_REG_CONTROL,
+                               data->global_control);
+               }
+               else
+                       printk("fscscy: writing to chip not supported\n");
+       }
+}
+
+#define TEMP_FROM_REG(val)    (val-128)
+
+
+void fscscy_temp(struct i2c_client *client, int operation, int ctl_name,
+              int *nrels_mag, long *results)
+{
+       struct fscscy_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               fscscy_update_client(client);
+               switch(ctl_name) {
+                       case FSCSCY_SYSCTL_TEMP0:
+                               results[0] = data->temp_status[0] & 0x03;
+                               results[1] = TEMP_FROM_REG(data->temp_act[0]);
+                               results[2] = TEMP_FROM_REG(data->temp_lim[0]);
+                               results[3] = TEMP_FROM_REG(data->temp_min[0]);
+                               results[4] = TEMP_FROM_REG(data->temp_max[0]);
+                               break;
+                       case FSCSCY_SYSCTL_TEMP1:
+                               results[0] = data->temp_status[1] & 0x03;
+                               results[1] = TEMP_FROM_REG(data->temp_act[1]);
+                               results[2] = TEMP_FROM_REG(data->temp_lim[1]);
+                               results[3] = TEMP_FROM_REG(data->temp_min[1]);
+                               results[4] = TEMP_FROM_REG(data->temp_max[1]);
+                               break;
+                       case FSCSCY_SYSCTL_TEMP2:
+                               results[0] = data->temp_status[2] & 0x03;
+                               results[1] = TEMP_FROM_REG(data->temp_act[2]);
+                               results[2] = TEMP_FROM_REG(data->temp_lim[2]);
+                               results[3] = TEMP_FROM_REG(data->temp_min[2]);
+                               results[4] = TEMP_FROM_REG(data->temp_max[2]);
+                               break;
+                       case FSCSCY_SYSCTL_TEMP3:
+                               results[0] = data->temp_status[3] & 0x03;
+                               results[1] = TEMP_FROM_REG(data->temp_act[3]);
+                               results[2] = TEMP_FROM_REG(data->temp_lim[3]);
+                               results[3] = TEMP_FROM_REG(data->temp_min[3]);
+                               results[4] = TEMP_FROM_REG(data->temp_max[3]);
+                               break;
+                       default:
+                               printk("fscscy: ctl_name %d not supported\n",
+                                       ctl_name);
+                               *nrels_mag = 0;
+                               return;
+               }
+               *nrels_mag = 5;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if(*nrels_mag >= 1) {
+                       switch(ctl_name) {
+                               case FSCSCY_SYSCTL_TEMP0:
+                                       data->temp_status[0] = 
+                                               (data->temp_status[0] & ~0x02) 
+                                               | (results[0] & 0x02);
+                                       printk("fscscy: writing value 0x%02x "
+                                               "to temp0_status\n",
+                                               data->temp_status[0]);
+                                       fscscy_write_value(client,
+                                               FSCSCY_REG_TEMP0_STATE,
+                                               data->temp_status[0] & 0x02);
+                                       break;
+                               case FSCSCY_SYSCTL_TEMP1:
+                                       data->temp_status[1] = (data->temp_status[1] & ~0x02) | (results[0] & 0x02);
+                                       printk("fscscy: writing value 0x%02x to temp1_status\n", data->temp_status[1]);
+                                       fscscy_write_value(client,FSCSCY_REG_TEMP1_STATE,
+                                               data->temp_status[1] & 0x02);
+                                       break;
+                               case FSCSCY_SYSCTL_TEMP2:
+                                       data->temp_status[2] = (data->temp_status[2] & ~0x02) | (results[0] & 0x02);
+                                       printk("fscscy: writing value 0x%02x to temp2_status\n", data->temp_status[2]);
+                                       fscscy_write_value(client,FSCSCY_REG_TEMP2_STATE,
+                                               data->temp_status[2] & 0x02);
+                                       break;
+                               case FSCSCY_SYSCTL_TEMP3:
+                                       data->temp_status[3] = (data->temp_status[3] & ~0x02) | (results[0] & 0x02);
+                                       printk("fscscy: writing value 0x%02x to temp3_status\n", data->temp_status[3]);
+                                       fscscy_write_value(client,FSCSCY_REG_TEMP3_STATE,
+                                               data->temp_status[3] & 0x02);
+                                       break;
+                               default:
+                                       printk("fscscy: ctl_name %d not supported\n",ctl_name);
+                       }
+               }
+               else
+                       printk("fscscy: writing to chip not supported\n");
+       }
+}
+
+#define VOLT_FROM_REG(val,mult)    (val*mult/255)
+
+void fscscy_volt(struct i2c_client *client, int operation, int ctl_name,
+              int *nrels_mag, long *results)
+{
+       struct fscscy_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 2;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               fscscy_update_client(client);
+               switch(ctl_name) {
+                       case FSCSCY_SYSCTL_VOLT0:
+                               results[0] = VOLT_FROM_REG(data->volt[0],1420);
+                               results[1] = VOLT_FROM_REG(data->volt_min[0],1420);
+                               results[2] = VOLT_FROM_REG(data->volt_max[0],1420);
+                               break;
+                       case FSCSCY_SYSCTL_VOLT1:
+                               results[0] = VOLT_FROM_REG(data->volt[1],660);
+                               results[1] = VOLT_FROM_REG(data->volt_min[1],660);
+                               results[2] = VOLT_FROM_REG(data->volt_max[1],660);
+                               break;
+                       case FSCSCY_SYSCTL_VOLT2:
+                               results[0] = VOLT_FROM_REG(data->volt[2],330);
+                               results[1] = VOLT_FROM_REG(data->volt_min[2],330);
+                               results[2] = VOLT_FROM_REG(data->volt_max[2],330);
+                               break;
+                       default:
+                               printk("fscscy: ctl_name %d not supported\n",
+                                       ctl_name);
+                               *nrels_mag = 0;
+                               return;
+               }
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+                       printk("fscscy: writing to chip not supported\n");
+       }
+}
+
+void fscscy_fan(struct i2c_client *client, int operation, int ctl_name,
+              int *nrels_mag, long *results)
+{
+
+       switch(ctl_name) {
+               case FSCSCY_SYSCTL_FAN0:
+                       fscscy_fan_internal(client,operation,ctl_name,nrels_mag,results,
+                               0,FSCSCY_REG_FAN0_STATE,FSCSCY_REG_FAN0_RPMMIN,
+                               FSCSCY_REG_FAN0_RIPPLE);
+                       break;
+               case FSCSCY_SYSCTL_FAN1:
+                       fscscy_fan_internal(client,operation,ctl_name,nrels_mag,results,
+                               1,FSCSCY_REG_FAN1_STATE,FSCSCY_REG_FAN1_RPMMIN,
+                               FSCSCY_REG_FAN1_RIPPLE);
+                       break;
+               case FSCSCY_SYSCTL_FAN2:
+                       fscscy_fan_internal(client,operation,ctl_name,nrels_mag,results,
+                               2,FSCSCY_REG_FAN2_STATE,FSCSCY_REG_FAN2_RPMMIN,
+                               FSCSCY_REG_FAN2_RIPPLE);
+                       break;
+               case FSCSCY_SYSCTL_FAN3:
+                       fscscy_fan_internal(client,operation,ctl_name,nrels_mag,results,
+                               3,FSCSCY_REG_FAN3_STATE,FSCSCY_REG_FAN3_RPMMIN,
+                               FSCSCY_REG_FAN3_RIPPLE);
+                       break;
+               case FSCSCY_SYSCTL_FAN4:
+                       fscscy_fan_internal(client,operation,ctl_name,nrels_mag,results,
+                               4,FSCSCY_REG_FAN4_STATE,FSCSCY_REG_FAN4_RPMMIN,
+                               FSCSCY_REG_FAN4_RIPPLE);
+                       break;
+               case FSCSCY_SYSCTL_FAN5:
+                       fscscy_fan_internal(client,operation,ctl_name,nrels_mag,results,
+                               5,FSCSCY_REG_FAN5_STATE,FSCSCY_REG_FAN5_RPMMIN,
+                               FSCSCY_REG_FAN5_RIPPLE);
+                       break;
+               default:
+                       printk("fscscy: illegal fan nr %d\n",ctl_name);
+       }
+}
+                       
+#define RPM_FROM_REG(val)   (val*60)
+
+void fscscy_fan_internal(struct i2c_client *client, int operation, int ctl_name,
+              int *nrels_mag, long *results, int nr,
+              int reg_state, int reg_min, int reg_ripple )
+{
+       struct fscscy_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               fscscy_update_client(client);
+               results[0] = data->fan_status[nr] & 0x0f; /* MKN */
+               results[1] = data->fan_rpmmin[nr];
+               results[2] = data->fan_ripple[nr] & 0x03;
+               results[3] = RPM_FROM_REG(data->fan_act[nr]);
+               results[4] = RPM_FROM_REG(data->fan_min[nr]);
+               results[5] = RPM_FROM_REG(data->fan_max[nr]);
+               *nrels_mag = 6;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if(*nrels_mag >= 1) {
+                       data->fan_status[nr] = (data->fan_status[nr] & 0x0b) | (results[0] & 0x04); /* MKN */
+                       printk("fscscy: writing value 0x%02x to fan%d_status\n",
+                               data->fan_status[nr],nr);
+                       fscscy_write_value(client,reg_state,
+                               data->fan_status[nr]);
+               }
+               if(*nrels_mag >= 2)  {
+                       if((results[1] & 0xff) == 0) {
+                                printk("fscscy: fan%d rpmmin 0 not allowed for safety reasons\n",nr);
+                                return;
+                       }
+                       data->fan_rpmmin[nr] = results[1];
+                       printk("fscscy: writing value 0x%02x to fan%d_min\n",
+                               data->fan_rpmmin[nr],nr);
+                       fscscy_write_value(client,reg_min,
+                               data->fan_rpmmin[nr]);
+               }
+               if(*nrels_mag >= 3) {
+                       if((results[2] & 0x03) == 0) {
+                               printk("fscscy: fan%d ripple 0 is nonsense/not allowed\n",nr);
+                               return;
+                       }
+                       data->fan_ripple[nr] = results[2] & 0x03;
+                       printk("fscscy: writing value 0x%02x to fan%d_ripple\n",
+                               data->fan_ripple[nr],nr);
+                       fscscy_write_value(client,reg_ripple,
+                               data->fan_ripple[nr]);
+               }       
+       }
+}
+
+void fscscy_wdog(struct i2c_client *client, int operation, int ctl_name,
+            int *nrels_mag, long *results)
+{
+       struct fscscy_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               fscscy_update_client(client);
+               results[0] = data->watchdog[0] ;
+               results[1] = data->watchdog[1] & 0x02;
+               results[2] = data->watchdog[2] & 0xb0;
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->watchdog[0] = results[0] & 0xff;
+                       printk("fscscy: writing value 0x%02x to wdog_preset\n",
+                               data->watchdog[0]); 
+                       fscscy_write_value(client,FSCSCY_REG_WDOG_PRESET,
+                               data->watchdog[0]);
+               } 
+               if (*nrels_mag >= 2) {
+                       data->watchdog[1] = results[1] & 0x02;
+                       printk("fscscy: writing value 0x%02x to wdog_state\n",
+                               data->watchdog[1]); 
+                       fscscy_write_value(client,FSCSCY_REG_WDOG_STATE,
+                               data->watchdog[1]);
+               }
+               if (*nrels_mag >= 3) {
+                       data->watchdog[2] = results[2] & 0xb0;
+                       printk("fscscy: writing value 0x%02x to wdog_control\n",
+                               data->watchdog[2]); 
+                       fscscy_write_value(client,FSCSCY_REG_WDOG_CONTROL,
+                               data->watchdog[2]);
+               }
+       }
+}
+
+void fscscy_pciload(struct i2c_client *client, int operation, int ctl_name,
+              int *nrels_mag, long *results)
+{
+       struct fscscy_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               fscscy_update_client(client);
+               results[0] = data->pciload;
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+                       printk("fscscy: writing PCILOAD to chip not supported\n");
+       }
+}
+
+void fscscy_intrusion(struct i2c_client *client, int operation, int ctl_name,
+            int *nrels_mag, long *results)
+{
+       struct fscscy_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               fscscy_update_client(client);
+               results[0] = data->intr_control & 0x80;
+               results[1] = data->intr_status & 0xc0;
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->intr_control = results[0] & 0x80;
+                       printk("fscscy: writing value 0x%02x to intr_control\n",
+                               data->intr_control); 
+                       fscscy_write_value(client,FSCSCY_REG_INTR_CTRL,
+                               data->intr_control);
+               } 
+       }
+}
+
+static int __init sm_fscscy_init(void)
+{
+       printk("fscscy.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       return i2c_add_driver(&fscscy_driver);
+}
+
+static void __exit sm_fscscy_exit(void)
+{
+       i2c_del_driver(&fscscy_driver);
+}
+
+
+
+MODULE_AUTHOR
+    ("Martin Knoblauch <mkn@teraport.de> based on work (fscpos) from  Hermann Jung <hej@odn.de>");
+MODULE_DESCRIPTION("fujitsu siemens scylla chip driver");
+
+module_init(sm_fscscy_init);
+module_exit(sm_fscscy_exit);
--- linux-old/drivers/sensors/gl518sm.c Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/gl518sm.c     Mon Dec 13 20:18:46 2004
@@ -0,0 +1,989 @@
+/*
+    gl518sm.c - Part of lm_sensors, Linux kernel modules for hardware
+                monitoring
+    Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl>,
+                              Kyösti Mälkki <kmalkki@cc.hut.fi>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+*/
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#ifdef __SMP__
+#include <linux/smp_lock.h>
+#endif
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+MODULE_LICENSE("GPL");
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = { 0x2c, 0x2d, SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { SENSORS_I2C_END };
+static unsigned int normal_isa[] = { SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+/* Insmod parameters */
+SENSORS_INSMOD_2(gl518sm_r00, gl518sm_r80);
+
+/* Defining this will enable debug messages for the voltage iteration
+   code used with rev 0 ICs */
+#undef DEBUG_VIN
+
+/* Many GL518 constants specified below */
+
+/* The GL518 registers */
+#define GL518_REG_CHIP_ID 0x00
+#define GL518_REG_REVISION 0x01
+#define GL518_REG_VENDOR_ID 0x02
+#define GL518_REG_CONF 0x03
+#define GL518_REG_TEMP 0x04
+#define GL518_REG_TEMP_OVER 0x05
+#define GL518_REG_TEMP_HYST 0x06
+#define GL518_REG_FAN_COUNT 0x07
+#define GL518_REG_FAN_LIMIT 0x08
+#define GL518_REG_VIN1_LIMIT 0x09
+#define GL518_REG_VIN2_LIMIT 0x0a
+#define GL518_REG_VIN3_LIMIT 0x0b
+#define GL518_REG_VDD_LIMIT 0x0c
+#define GL518_REG_VIN3 0x0d
+#define GL518_REG_MISC 0x0f
+#define GL518_REG_ALARM 0x10
+#define GL518_REG_MASK 0x11
+#define GL518_REG_INT 0x12
+#define GL518_REG_VIN2 0x13
+#define GL518_REG_VIN1 0x14
+#define GL518_REG_VDD 0x15
+
+
+/* Conversions. Rounding and limit checking is only done on the TO_REG
+   variants. Note that you should be a bit careful with which arguments
+   these macros are called: arguments may be evaluated more than once.
+   Fixing this is just not worth it. */
+
+#define TEMP_TO_REG(val) (SENSORS_LIMIT(((((val)<0?(val)-5:(val)+5) / 10)+119),\
+                                        0,255))
+#define TEMP_FROM_REG(val) (((val) - 119) * 10)
+
+static inline u8 FAN_TO_REG(long rpm, int div)
+{
+       if (rpm == 0)
+               return 255;
+       rpm = SENSORS_LIMIT(rpm, 1, 1000000);
+       return SENSORS_LIMIT((960000 + rpm * div / 2) / (rpm * div), 1,
+                            254);
+}
+
+#define FAN_FROM_REG(val,div) \
+ ( (val)==0 ? 0 : (val)==255 ? 0 : (960000/((val)*(div))) )
+
+#define IN_TO_REG(val) (SENSORS_LIMIT((((val)*10+8)/19),0,255))
+#define IN_FROM_REG(val) (((val)*19)/10)
+
+#define VDD_TO_REG(val) (SENSORS_LIMIT((((val)*10+11)/23),0,255))
+#define VDD_FROM_REG(val) (((val)*23)/10)
+
+#define DIV_TO_REG(val) ((val)==8?3:(val)==4?2:(val)==1?0:1)
+#define DIV_FROM_REG(val) (1 << (val))
+
+#define ALARMS_FROM_REG(val) val
+
+#define BEEP_ENABLE_TO_REG(val) ((val)?0:1)
+#define BEEP_ENABLE_FROM_REG(val) ((val)?0:1)
+
+#define BEEPS_TO_REG(val) ((val) & 0x7f)
+#define BEEPS_FROM_REG(val) ((val) & 0x7f)
+
+/* Each client has this additional data */
+struct gl518_data {
+       struct i2c_client client;
+       int sysctl_id;
+       enum chips type;
+
+       struct semaphore update_lock;
+
+       int iterate_lock;
+       int quit_thread;
+       struct task_struct *thread;
+       wait_queue_head_t wq;
+       char valid;             /* !=0 if following fields are valid */
+       unsigned long last_updated;     /* In jiffies */
+       unsigned long last_updated_v00;
+       /* In jiffies (used only by rev00 chips) */
+
+       u8 voltage[4];          /* Register values; [0] = VDD */
+       u8 voltage_min[4];      /* Register values; [0] = VDD */
+       u8 voltage_max[4];      /* Register values; [0] = VDD */
+       u8 iter_voltage[4];     /* Register values; [0] = VDD */
+       u8 fan[2];
+       u8 fan_min[2];
+       u8 temp;                /* Register values */
+       u8 temp_over;           /* Register values */
+       u8 temp_hyst;           /* Register values */
+       u8 alarms, beeps;       /* Register value */
+       u8 alarm_mask;          /* Register value */
+       u8 fan_div[2];          /* Register encoding, shifted right */
+       u8 beep_enable;         /* Boolean */
+       u8 iterate;             /* Voltage iteration mode */
+};
+
+static int gl518_attach_adapter(struct i2c_adapter *adapter);
+static int gl518_detect(struct i2c_adapter *adapter, int address,
+                       unsigned short flags, int kind);
+static void gl518_init_client(struct i2c_client *client);
+static int gl518_detach_client(struct i2c_client *client);
+
+static int gl518_read_value(struct i2c_client *client, u8 reg);
+static int gl518_write_value(struct i2c_client *client, u8 reg, u16 value);
+static void gl518_update_client(struct i2c_client *client);
+
+static void gl518_update_client_rev00(struct i2c_client *client);
+static void gl518_update_iterate(struct i2c_client *client);
+
+static void gl518_vin(struct i2c_client *client, int operation,
+                     int ctl_name, int *nrels_mag, long *results);
+static void gl518_fan(struct i2c_client *client, int operation,
+                     int ctl_name, int *nrels_mag, long *results);
+static void gl518_temp(struct i2c_client *client, int operation,
+                      int ctl_name, int *nrels_mag, long *results);
+static void gl518_fan_div(struct i2c_client *client, int operation,
+                         int ctl_name, int *nrels_mag, long *results);
+static void gl518_alarms(struct i2c_client *client, int operation,
+                        int ctl_name, int *nrels_mag, long *results);
+static void gl518_beep(struct i2c_client *client, int operation,
+                      int ctl_name, int *nrels_mag, long *results);
+static void gl518_fan1off(struct i2c_client *client, int operation,
+                         int ctl_name, int *nrels_mag, long *results);
+static void gl518_iterate(struct i2c_client *client, int operation,
+                         int ctl_name, int *nrels_mag, long *results);
+
+/* This is the driver that will be inserted */
+static struct i2c_driver gl518_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "GL518SM sensor chip driver",
+       .id             = I2C_DRIVERID_GL518,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = gl518_attach_adapter,
+       .detach_client  = gl518_detach_client,
+};
+
+/* -- SENSORS SYSCTL START -- */
+
+#define GL518_SYSCTL_VDD  1000 /* Volts * 100 */
+#define GL518_SYSCTL_VIN1 1001
+#define GL518_SYSCTL_VIN2 1002
+#define GL518_SYSCTL_VIN3 1003
+#define GL518_SYSCTL_FAN1 1101 /* RPM */
+#define GL518_SYSCTL_FAN2 1102
+#define GL518_SYSCTL_TEMP 1200 /* Degrees Celcius * 10 */
+#define GL518_SYSCTL_FAN_DIV 2000      /* 1, 2, 4 or 8 */
+#define GL518_SYSCTL_ALARMS 2001       /* bitvector */
+#define GL518_SYSCTL_BEEP 2002 /* bitvector */
+#define GL518_SYSCTL_FAN1OFF 2003
+#define GL518_SYSCTL_ITERATE 2004
+
+#define GL518_ALARM_VDD 0x01
+#define GL518_ALARM_VIN1 0x02
+#define GL518_ALARM_VIN2 0x04
+#define GL518_ALARM_VIN3 0x08
+#define GL518_ALARM_TEMP 0x10
+#define GL518_ALARM_FAN1 0x20
+#define GL518_ALARM_FAN2 0x40
+
+/* -- SENSORS SYSCTL END -- */
+
+/* These files are created for each detected GL518. This is just a template;
+   though at first sight, you might think we could use a statically
+   allocated list, we need some way to get back to the parent - which
+   is done through one of the 'extra' fields which are initialized
+   when a new copy is allocated. */
+static ctl_table gl518_dir_table_template[] = {
+       {GL518_SYSCTL_VIN1, "in1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &gl518_vin},
+       {GL518_SYSCTL_VIN2, "in2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &gl518_vin},
+       {GL518_SYSCTL_VIN3, "in3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &gl518_vin},
+       {GL518_SYSCTL_VDD, "in0", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &gl518_vin},
+       {GL518_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &gl518_fan},
+       {GL518_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &gl518_fan},
+       {GL518_SYSCTL_TEMP, "temp", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &gl518_temp},
+       {GL518_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &gl518_fan_div},
+       {GL518_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &gl518_alarms},
+       {GL518_SYSCTL_BEEP, "beep", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &gl518_beep},
+       {GL518_SYSCTL_FAN1OFF, "fan1off", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &gl518_fan1off},
+       {GL518_SYSCTL_ITERATE, "iterate", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &gl518_iterate},
+       {0}
+};
+
+/* I choose here for semi-static GL518SM allocation. Complete dynamic
+   allocation could also be used; the code needed for this would probably
+   take more memory than the datastructure takes now. */
+#define MAX_GL518_NR 4
+static struct i2c_client *gl518_list[MAX_GL518_NR];
+
+static int gl518_attach_adapter(struct i2c_adapter *adapter)
+{
+       return i2c_detect(adapter, &addr_data, gl518_detect);
+}
+
+static int gl518_detect(struct i2c_adapter *adapter, int address,
+                       unsigned short flags, int kind)
+{
+       int i;
+       struct i2c_client *new_client;
+       struct gl518_data *data;
+       int err = 0;
+       const char *type_name = "";
+       const char *client_name = "";
+
+       /* Make sure we aren't probing the ISA bus!! This is just a safety check
+          at this moment; i2c_detect really won't call us. */
+#ifdef DEBUG
+       if (i2c_is_isa_adapter(adapter)) {
+               printk
+                   ("gl518sm.o: gl518_detect called for an ISA bus adapter?!?\n");
+               return 0;
+       }
+#endif
+
+       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
+                                    I2C_FUNC_SMBUS_WORD_DATA))
+                   goto ERROR0;
+
+       /* OK. For now, we presume we have a valid client. We now create the
+          client structure, even though we cannot fill it completely yet.
+          But it allows us to access gl518_{read,write}_value. */
+
+       if (!(data = kmalloc(sizeof(struct gl518_data), GFP_KERNEL))) {
+               err = -ENOMEM;
+               goto ERROR0;
+       }
+
+       new_client = &data->client;
+       new_client->addr = address;
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &gl518_driver;
+       new_client->flags = 0;
+
+       /* Now, we do the remaining detection. */
+
+       if (kind < 0) {
+               if (
+                   (gl518_read_value(new_client, GL518_REG_CHIP_ID) !=
+                    0x80)
+                   || (gl518_read_value(new_client, GL518_REG_CONF) &
+                       0x80)) goto ERROR1;
+       }
+
+       /* Determine the chip type. */
+       if (kind <= 0) {
+               i = gl518_read_value(new_client, GL518_REG_REVISION);
+               if (i == 0x00)
+                       kind = gl518sm_r00;
+               else if (i == 0x80)
+                       kind = gl518sm_r80;
+               else {
+                       if (kind == 0)
+                               printk
+                                   ("gl518sm.o: Ignoring 'force' parameter for unknown chip at "
+                                    "adapter %d, address 0x%02x\n",
+                                    i2c_adapter_id(adapter), address);
+                       goto ERROR1;
+               }
+       }
+
+       type_name = "gl518sm";
+       if (kind == gl518sm_r00) {
+               client_name = "GL518SM Revision 0x00 chip";
+       } else if (kind == gl518sm_r80) {
+               client_name = "GL518SM Revision 0x80 chip";
+       } else {
+#ifdef DEBUG
+               printk("gl518sm.o: Internal error: unknown kind (%d)?!?",
+                      kind);
+#endif
+               goto ERROR1;
+       }
+
+       /* Fill in the remaining client fields and put it into the global list */
+       strcpy(new_client->name, client_name);
+       data->type = kind;
+
+       for (i = 0; i < MAX_GL518_NR; i++)
+               if (!gl518_list[i])
+                       break;
+       if (i == MAX_GL518_NR) {
+               printk
+                   ("gl518sm.o: No empty slots left, recompile and heighten "
+                    "MAX_GL518_NR!\n");
+               err = -ENOMEM;
+               goto ERROR2;
+       }
+       gl518_list[i] = new_client;
+       new_client->id = i;
+       data->valid = 0;
+       init_MUTEX(&data->update_lock);
+
+       /* Tell the I2C layer a new client has arrived */
+       if ((err = i2c_attach_client(new_client)))
+               goto ERROR3;
+
+       /* Register a new directory entry with module sensors */
+       if ((i = i2c_register_entry((struct i2c_client *) new_client,
+                                       type_name,
+                                       gl518_dir_table_template)) < 0) {
+               err = i;
+               goto ERROR4;
+       }
+       data->sysctl_id = i;
+
+       /* Initialize the GL518SM chip */
+       if (kind == gl518sm_r00)
+               data->iterate = 0;
+       else
+               data->iterate = 3;
+       data->iterate_lock = 0;
+       data->quit_thread = 0;
+       data->thread = NULL;
+       data->alarm_mask = 0xff;
+       data->voltage[0]=data->voltage[1]=data->voltage[2]=0;
+       gl518_init_client((struct i2c_client *) new_client);
+       return 0;
+
+/* OK, this is not exactly good programming practice, usually. But it is
+   very code-efficient in this case. */
+
+      ERROR4:
+       i2c_detach_client(new_client);
+      ERROR3:
+       for (i = 0; i < MAX_GL518_NR; i++)
+               if (new_client == gl518_list[i])
+                       gl518_list[i] = NULL;
+      ERROR2:
+      ERROR1:
+       kfree(data);
+      ERROR0:
+       return err;
+}
+
+
+/* Called when we have found a new GL518SM. It should set limits, etc. */
+static void gl518_init_client(struct i2c_client *client)
+{
+       /* Power-on defaults (bit 7=1) */
+       gl518_write_value(client, GL518_REG_CONF, 0x80);
+
+       /* No noisy output (bit 2=1), Comparator mode (bit 3=0), two fans (bit4=0),
+          standby mode (bit6=0) */
+       gl518_write_value(client, GL518_REG_CONF, 0x04);
+
+       /* Never interrupts */
+       gl518_write_value(client, GL518_REG_MASK, 0x00);
+
+       /* Clear status register (bit 5=1), start (bit6=1) */
+       gl518_write_value(client, GL518_REG_CONF, 0x24);
+       gl518_write_value(client, GL518_REG_CONF, 0x44);
+}
+
+static int gl518_detach_client(struct i2c_client *client)
+{
+       int err, i;
+       struct gl518_data *data = client->data;
+
+       i2c_deregister_entry(((struct gl518_data *) (client->data))->
+                                sysctl_id);
+
+       if ((err = i2c_detach_client(client))) {
+               printk
+                   ("gl518sm.o: Client deregistration failed, client not detached.\n");
+               return err;
+       }
+
+       for (i = 0; i < MAX_GL518_NR; i++)
+               if (client == gl518_list[i])
+                       break;
+       if ((i == MAX_GL518_NR)) {
+               printk("gl518sm.o: Client to detach not found.\n");
+               return -ENOENT;
+       }
+       gl518_list[i] = NULL;
+
+       if (data->thread) {
+               data->quit_thread = 1;
+               wake_up_interruptible(&data->wq);
+       }
+
+       kfree(client->data);
+
+       return 0;
+}
+
+
+/* Registers 0x07 to 0x0c are word-sized, others are byte-sized 
+   GL518 uses a high-byte first convention, which is exactly opposite to
+   the usual practice. */
+static int gl518_read_value(struct i2c_client *client, u8 reg)
+{
+       if ((reg >= 0x07) && (reg <= 0x0c))
+               return swab16(i2c_smbus_read_word_data(client, reg));
+       else
+               return i2c_smbus_read_byte_data(client, reg);
+}
+
+/* Registers 0x07 to 0x0c are word-sized, others are byte-sized 
+   GL518 uses a high-byte first convention, which is exactly opposite to
+   the usual practice. */
+static int gl518_write_value(struct i2c_client *client, u8 reg, u16 value)
+{
+       if ((reg >= 0x07) && (reg <= 0x0c))
+               return i2c_smbus_write_word_data(client, reg, swab16(value));
+       else
+               return i2c_smbus_write_byte_data(client, reg, value);
+}
+
+static void gl518_update_client(struct i2c_client *client)
+{
+       struct gl518_data *data = client->data;
+       int val;
+
+       down(&data->update_lock);
+
+       if ((jiffies - data->last_updated > HZ + HZ / 2) ||
+           (jiffies < data->last_updated) || !data->valid) {
+
+#ifdef DEBUG
+               printk("Starting gl518 update\n");
+#endif
+
+               data->alarms = gl518_read_value(client, GL518_REG_INT);
+               data->beeps = gl518_read_value(client, GL518_REG_ALARM);
+
+               val = gl518_read_value(client, GL518_REG_VDD_LIMIT);
+               data->voltage_min[0] = val & 0xff;
+               data->voltage_max[0] = (val >> 8) & 0xff;
+               val = gl518_read_value(client, GL518_REG_VIN1_LIMIT);
+               data->voltage_min[1] = val & 0xff;
+               data->voltage_max[1] = (val >> 8) & 0xff;
+               val = gl518_read_value(client, GL518_REG_VIN2_LIMIT);
+               data->voltage_min[2] = val & 0xff;
+               data->voltage_max[2] = (val >> 8) & 0xff;
+               val = gl518_read_value(client, GL518_REG_VIN3_LIMIT);
+               data->voltage_min[3] = val & 0xff;
+               data->voltage_max[3] = (val >> 8) & 0xff;
+
+               val = gl518_read_value(client, GL518_REG_FAN_COUNT);
+               data->fan[0] = (val >> 8) & 0xff;
+               data->fan[1] = val & 0xff;
+
+               val = gl518_read_value(client, GL518_REG_FAN_LIMIT);
+               data->fan_min[0] = (val >> 8) & 0xff;
+               data->fan_min[1] = val & 0xff;
+
+               data->temp = gl518_read_value(client, GL518_REG_TEMP);
+               data->temp_over =
+                   gl518_read_value(client, GL518_REG_TEMP_OVER);
+               data->temp_hyst =
+                   gl518_read_value(client, GL518_REG_TEMP_HYST);
+
+               val = gl518_read_value(client, GL518_REG_MISC);
+               data->fan_div[0] = (val >> 6) & 0x03;
+               data->fan_div[1] = (val >> 4) & 0x03;
+
+               data->alarms &= data->alarm_mask;
+
+               val = gl518_read_value(client, GL518_REG_CONF);
+               data->beep_enable = (val >> 2) & 1;
+
+#ifndef DEBUG_VIN
+               if (data->type != gl518sm_r00) {
+                       data->voltage[0] =
+                           gl518_read_value(client, GL518_REG_VDD);
+                       data->voltage[1] =
+                           gl518_read_value(client, GL518_REG_VIN1);
+                       data->voltage[2] =
+                           gl518_read_value(client, GL518_REG_VIN2);
+                       data->voltage[3] =
+                           gl518_read_value(client, GL518_REG_VIN3);
+               } else
+                       gl518_update_client_rev00(client);
+#else
+               gl518_update_client_rev00(client);
+#endif
+
+               data->last_updated = jiffies;
+               data->valid = 1;
+       }
+
+       up(&data->update_lock);
+}
+
+/* Here we decide how to run the iteration code.
+   When called, we trigger the iteration and report the last
+   measured voltage. No delay for user apps */
+static void gl518_update_client_rev00(struct i2c_client *client)
+{
+       struct gl518_data *data = client->data;
+       int i;
+
+       if (data->iterate == 1) {       /* 10 sec delay */
+               /* as that update is slow, we consider the data valid for 30 seconds */
+               if (
+                   ((jiffies - data->last_updated_v00 > 30 * HZ)
+                    || (data->alarms & 7)
+                    || (!data->valid)) && (!data->iterate_lock)) {
+                       data->iterate_lock = 1;
+                       gl518_update_iterate(client);
+                       data->iterate_lock = 0;
+               }
+               for (i = 0; i < 4; i++)
+                       data->voltage[i] = data->iter_voltage[i];
+       } else if (data->iterate == 2) {        /* show results of last iteration */
+               for (i = 0; i < 4; i++)
+                       data->voltage[i] = data->iter_voltage[i];
+               wake_up_interruptible(&data->wq);
+       } else {                /* no iteration */
+               data->voltage[3] =
+                   gl518_read_value(client, GL518_REG_VIN3);
+       }
+}
+
+static int gl518_update_thread(void *c)
+{
+       struct i2c_client *client = c;
+       struct gl518_data *data = client->data;
+
+#ifdef __SMP__
+       lock_kernel();
+#endif
+       exit_mm(current);
+       current->session = 1;
+       current->pgrp = 1;
+       sigfillset(&current->blocked);
+       current->fs->umask = 0;
+       strcpy(current->comm, "gl518sm");
+
+       init_waitqueue_head(&(data->wq));
+       data->thread = current;
+
+#ifdef __SMP__
+       unlock_kernel();
+#endif
+
+       for (;;) {
+               if (!data->iterate_lock) {
+                       data->iterate_lock = 1;
+                       gl518_update_iterate(client);
+                       data->iterate_lock = 0;
+               }
+
+               if ((data->quit_thread) || signal_pending(current))
+                       break;
+               interruptible_sleep_on(&data->wq);
+       }
+
+       data->thread = NULL;
+       data->quit_thread = 0;
+       return 0;
+}
+
+/* This updates vdd, vin1, vin2 values by doing slow and multiple
+   comparisons for the GL518SM rev 00 that lacks support for direct
+   reading of these values.   Values are kept in iter_voltage   */
+
+static void gl518_update_iterate(struct i2c_client *client)
+{
+       struct gl518_data *data = client->data;
+       int i, j, loop_more = 1, min[3], max[3], delta[3];
+       int alarm, beeps, irqs;
+
+#define VIN_REG(c) c==0?GL518_REG_VDD_LIMIT:\
+                   c==1?GL518_REG_VIN1_LIMIT:\
+                   GL518_REG_VIN2_LIMIT
+
+       /* disable beeps & irqs for vin0-2 */
+       beeps = gl518_read_value(client, GL518_REG_ALARM);
+       irqs = gl518_read_value(client, GL518_REG_MASK);
+       gl518_write_value(client, GL518_REG_ALARM, beeps & ~0x7);
+       gl518_write_value(client, GL518_REG_MASK, irqs & ~0x7);
+
+       alarm = data->alarms;
+
+       for (i = 0; i < 3; i++) {
+               if (alarm & (1 << i)) {
+                       min[i] = 0;
+                       max[i] = 127;
+               } else {
+                       min[i] = data->voltage_min[i];
+                       max[i] =
+                           (data->voltage_max[i] +
+                            data->voltage_min[i]) / 2;
+               }
+               delta[i] = (max[i] - min[i]) / 2;
+       }
+
+       for (j = 0; (j < 10 && loop_more); j++) {
+
+               for (i = 0; i < 3; i++)
+                       gl518_write_value(client, VIN_REG(i),
+                                         max[i] << 8 | min[i]);
+
+               if ((data->thread) &&
+                   ((data->quit_thread) || signal_pending(current)))
+                       goto finish;
+
+               /* we wait now 1.5 seconds before comparing */
+               current->state = TASK_INTERRUPTIBLE;
+               schedule_timeout(HZ + HZ / 2);
+
+               alarm = gl518_read_value(client, GL518_REG_INT);
+
+#ifdef DEBUG_VIN
+               printk("gl518sm: iteration %2d: %4d%c %4d%c %4d%c\n", j,
+                      max[0], (alarm & 1) ? '!' : ' ',
+                      max[1], (alarm & 2) ? '!' : ' ',
+                      max[2], (alarm & 4) ? '!' : ' ');
+#endif
+
+               for (loop_more = 0, i = 0; i < 3; i++) {
+                       if (alarm & (1 << i))
+                               max[i] += delta[i];
+                       else
+                               max[i] -= delta[i];
+
+                       if (delta[i])
+                               loop_more++;
+                       delta[i] >>= 1;
+               }
+
+       }
+
+       for (i = 0; i < 3; i++)
+               if (alarm & (1 << i))
+                       max[i]++;
+
+#ifdef DEBUG_VIN
+       printk("gl518sm:    final   :%5d %5d %5d\n", max[0], max[1],
+              max[2]);
+       printk("gl518sm:    meter   :%5d %5d %5d\n", data->voltage[0],
+              data->voltage[1], data->voltage[2]);
+#endif
+
+       /* update values, including vin3 */
+       for (i = 0; i < 3; i++) {
+               data->iter_voltage[i] = max[i];
+       }
+       data->iter_voltage[3] = gl518_read_value(client, GL518_REG_VIN3);
+       data->last_updated_v00 = jiffies;
+
+      finish:
+
+       /* reset values */
+       for (i = 0; i < 3; i++) {
+               gl518_write_value(client, VIN_REG(i),
+                                 data->voltage_max[i] << 8 | data->
+                                 voltage_min[i]);
+       }
+
+       gl518_write_value(client, GL518_REG_ALARM, beeps);
+       gl518_write_value(client, GL518_REG_MASK, irqs);
+
+#undef VIN_REG
+}
+
+void gl518_temp(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       struct gl518_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               gl518_update_client(client);
+               results[0] = TEMP_FROM_REG(data->temp_over);
+               results[1] = TEMP_FROM_REG(data->temp_hyst);
+               results[2] = TEMP_FROM_REG(data->temp);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->temp_over = TEMP_TO_REG(results[0]);
+                       gl518_write_value(client, GL518_REG_TEMP_OVER,
+                                         data->temp_over);
+               }
+               if (*nrels_mag >= 2) {
+                       data->temp_hyst = TEMP_TO_REG(results[1]);
+                       gl518_write_value(client, GL518_REG_TEMP_HYST,
+                                         data->temp_hyst);
+               }
+       }
+}
+
+void gl518_vin(struct i2c_client *client, int operation, int ctl_name,
+              int *nrels_mag, long *results)
+{
+       struct gl518_data *data = client->data;
+       int nr = ctl_name - GL518_SYSCTL_VDD;
+       int regnr, old = 0;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 2;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               gl518_update_client(client);
+               results[0] = nr ? IN_FROM_REG(data->voltage_min[nr]) :
+                   VDD_FROM_REG(data->voltage_min[nr]);
+               results[1] = nr ? IN_FROM_REG(data->voltage_max[nr]) :
+                   VDD_FROM_REG(data->voltage_max[nr]);
+               results[2] = nr ? IN_FROM_REG(data->voltage[nr]) :
+                   VDD_FROM_REG(data->voltage[nr]);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               regnr =
+                   nr == 0 ? GL518_REG_VDD_LIMIT : nr ==
+                   1 ? GL518_REG_VIN1_LIMIT : nr ==
+                   2 ? GL518_REG_VIN2_LIMIT : GL518_REG_VIN3_LIMIT;
+               if (*nrels_mag == 1)
+                       old = gl518_read_value(client, regnr) & 0xff00;
+               if (*nrels_mag >= 2) {
+                       data->voltage_max[nr] =
+                           nr ? IN_TO_REG(results[1]) :
+                           VDD_TO_REG(results[1]);
+                       old = data->voltage_max[nr] << 8;
+               }
+               if (*nrels_mag >= 1) {
+                       data->voltage_min[nr] =
+                           nr ? IN_TO_REG(results[0]) :
+                           VDD_TO_REG(results[0]);
+                       old |= data->voltage_min[nr];
+                       gl518_write_value(client, regnr, old);
+               }
+       }
+}
+
+
+void gl518_fan(struct i2c_client *client, int operation, int ctl_name,
+              int *nrels_mag, long *results)
+{
+       struct gl518_data *data = client->data;
+       int nr = ctl_name - GL518_SYSCTL_FAN1;
+       int old;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               gl518_update_client(client);
+               results[0] = FAN_FROM_REG(data->fan_min[nr],
+                                         DIV_FROM_REG(data->fan_div[nr]));
+               results[1] =
+                   FAN_FROM_REG(data->fan[nr],
+                                DIV_FROM_REG(data->fan_div[nr]));
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->fan_min[nr] = FAN_TO_REG(results[0],
+                                                      DIV_FROM_REG(data->
+                                                                   fan_div
+                                                                   [nr]));
+                       old =
+                           gl518_read_value(client, GL518_REG_FAN_LIMIT);
+
+                       if (nr == 0) {
+                               old =
+                                   (old & 0x00ff) | (data->
+                                                     fan_min[0] << 8);
+                               if (results[0] == 0)
+                                       data->alarm_mask &= ~0x20;
+                               else
+                                       data->alarm_mask |= 0x20;
+                       } else {
+                               old = (old & 0xff00) | data->fan_min[1];
+                               if (results[0] == 0)
+                                       data->alarm_mask &= ~0x40;
+                               else
+                                       data->alarm_mask |= 0x40;
+                       }
+                       gl518_write_value(client, GL518_REG_FAN_LIMIT,
+                                         old);
+               }
+       }
+}
+
+
+void gl518_alarms(struct i2c_client *client, int operation, int ctl_name,
+                 int *nrels_mag, long *results)
+{
+       struct gl518_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               gl518_update_client(client);
+               results[0] = ALARMS_FROM_REG(data->alarms);
+               *nrels_mag = 1;
+       }
+}
+
+void gl518_beep(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       struct gl518_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               gl518_update_client(client);
+               results[0] = BEEP_ENABLE_FROM_REG(data->beep_enable);
+               results[1] = BEEPS_FROM_REG(data->beeps);
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->beep_enable = BEEP_ENABLE_TO_REG(results[0]);
+                       gl518_write_value(client, GL518_REG_CONF,
+                                         (gl518_read_value(client,
+                                                           GL518_REG_CONF)
+                                          & 0xfb) | (data->
+                                                     beep_enable << 2));
+               }
+               if (*nrels_mag >= 2) {
+                       data->beeps =
+                           BEEPS_TO_REG(results[1]) & data->alarm_mask;
+                       gl518_write_value(client, GL518_REG_ALARM,
+                                         data->beeps);
+               }
+       }
+}
+
+
+void gl518_fan_div(struct i2c_client *client, int operation, int ctl_name,
+                  int *nrels_mag, long *results)
+{
+       struct gl518_data *data = client->data;
+       int old;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               gl518_update_client(client);
+               results[0] = DIV_FROM_REG(data->fan_div[0]);
+               results[1] = DIV_FROM_REG(data->fan_div[1]);
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               old = gl518_read_value(client, GL518_REG_MISC);
+               if (*nrels_mag >= 2) {
+                       data->fan_div[1] = DIV_TO_REG(results[1]);
+                       old = (old & 0xcf) | (data->fan_div[1] << 4);
+               }
+               if (*nrels_mag >= 1) {
+                       data->fan_div[0] = DIV_TO_REG(results[0]);
+                       old = (old & 0x3f) | (data->fan_div[0] << 6);
+               }
+               gl518_write_value(client, GL518_REG_MISC, old);
+       }
+}
+
+void gl518_fan1off(struct i2c_client *client, int operation, int ctl_name,
+                  int *nrels_mag, long *results)
+{
+       int old;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               results[0] =
+                   ((gl518_read_value(client, GL518_REG_MISC) & 0x08) !=
+                    0);
+               results[1] =
+                   ((gl518_read_value(client, GL518_REG_CONF) & 0x10) !=
+                    0);
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       old =
+                           gl518_read_value(client,
+                                            GL518_REG_MISC) & 0xf7;
+                       if (results[0])
+                               old |= 0x08;
+                       gl518_write_value(client, GL518_REG_MISC, old);
+               }
+               if (*nrels_mag >= 2) {
+                       old =
+                           gl518_read_value(client,
+                                            GL518_REG_CONF) & 0xef;
+                       if (results[1])
+                               old |= 0x10;
+                       gl518_write_value(client, GL518_REG_CONF, old);
+               }
+       }
+}
+
+void gl518_iterate(struct i2c_client *client, int operation, int ctl_name,
+                  int *nrels_mag, long *results)
+{
+       struct gl518_data *data = client->data;
+       int i;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               results[0] = data->iterate;
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE &&
+                  data->type == gl518sm_r00 ) {
+               if ((*nrels_mag >= 1) && (data->iterate != results[0])) {
+                       data->iterate = results[0];
+                       for (i = 0; i < 4; i++) {
+                               data->voltage[i] = 0;
+                               data->iter_voltage[i] = 0;
+                       }
+                       data->valid = 0;
+
+                       if ((data->iterate != 2) && (data->thread)) {
+                               data->quit_thread = 1;
+                               wake_up_interruptible(&data->wq);
+                       } else if ((data->iterate == 2) && (!data->thread)) {
+                               init_waitqueue_head(&(data->wq));
+                               kernel_thread(gl518_update_thread,
+                                             (void *) client, 0);
+                       }
+               }
+       }
+}
+
+static int __init sm_gl518sm_init(void)
+{
+       printk("gl518sm.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       return i2c_add_driver(&gl518_driver);
+}
+
+static void __exit sm_gl518sm_exit(void)
+{
+       i2c_del_driver(&gl518_driver);
+}
+
+
+
+MODULE_AUTHOR
+    ("Frodo Looijaard <frodol@dds.nl> and Kyösti Mälkki <kmalkki@cc.hut.fi>");
+MODULE_DESCRIPTION("GL518SM driver");
+
+module_init(sm_gl518sm_init);
+module_exit(sm_gl518sm_exit);
--- linux-old/drivers/sensors/gl520sm.c Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/gl520sm.c     Mon Dec 13 20:18:47 2004
@@ -0,0 +1,809 @@
+/*
+    gl520sm.c - Part of lm_sensors, Linux kernel modules for hardware
+                monitoring
+    Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl>,
+                              Kyösti Mälkki <kmalkki@cc.hut.fi>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+*/
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+MODULE_LICENSE("GPL");
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = { 0x2c, 0x2d, SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { SENSORS_I2C_END };
+static unsigned int normal_isa[] = { SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+/* Insmod parameters */
+SENSORS_INSMOD_1(gl520sm);
+
+/* Many GL520 constants specified below 
+One of the inputs can be configured as either temp or voltage.
+That's why _TEMP2 and _VIN4 access the same register 
+*/
+
+/* The GL520 registers */
+#define GL520_REG_CHIP_ID 0x00
+#define GL520_REG_REVISION 0x01
+#define GL520_REG_VID 0x02
+#define GL520_REG_CONF 0x03
+#define GL520_REG_TEMP1 0x04
+#define GL520_REG_TEMP1_OVER 0x05
+#define GL520_REG_TEMP1_HYST 0x06
+#define GL520_REG_FAN_COUNT 0x07
+#define GL520_REG_FAN_LIMIT 0x08
+#define GL520_REG_VIN1_LIMIT 0x09
+#define GL520_REG_VIN2_LIMIT 0x0a
+#define GL520_REG_VIN3_LIMIT 0x0b
+#define GL520_REG_VDD_LIMIT 0x0c
+#define GL520_REG_VIN3 0x0d
+#define GL520_REG_VIN4 0x0e
+#define GL520_REG_TEMP2 0x0e
+#define GL520_REG_MISC 0x0f
+#define GL520_REG_ALARM 0x10
+#define GL520_REG_MASK 0x11
+#define GL520_REG_INT 0x12
+#define GL520_REG_VIN2 0x13
+#define GL520_REG_VIN1 0x14
+#define GL520_REG_VDD 0x15
+#define GL520_REG_TEMP2_OVER 0x17
+#define GL520_REG_VIN4_MAX 0x17
+#define GL520_REG_TEMP2_HYST 0x18
+#define GL520_REG_VIN4_MIN 0x18
+
+
+/* Conversions. Rounding and limit checking is only done on the TO_REG
+   variants. Note that you should be a bit careful with which arguments
+   these macros are called: arguments may be evaluated more than once.
+   Fixing this is just not worth it. */
+
+#define TEMP_TO_REG(val) (SENSORS_LIMIT(((((val)<0?(val)-5:(val)+5) / 10)+130),\
+                                        0,255))
+#define TEMP_FROM_REG(val) (((val) - 130) * 10)
+
+static inline u8 FAN_TO_REG(long rpm, int div)
+{
+       if (rpm == 0)
+               return 255;
+       rpm = SENSORS_LIMIT(rpm, 1, 1000000);
+       return SENSORS_LIMIT((960000 + rpm * div / 2) / (rpm * div), 1,
+                            254);
+}
+
+#define FAN_FROM_REG(val,div) \
+ ( (val)==0 ? 0 : (val)==255 ? 0 : (960000/((val)*(div))) )
+
+#define IN_TO_REG(val) (SENSORS_LIMIT((((val)*10+8)/19),0,255))
+#define IN_FROM_REG(val) (((val)*19)/10)
+
+#define VDD_TO_REG(val) (SENSORS_LIMIT((((val)*10+11)/23),0,255))
+#define VDD_FROM_REG(val) (((val)*23)/10)
+
+#define DIV_TO_REG(val) ((val)==8?3:(val)==4?2:(val)==1?0:1)
+#define DIV_FROM_REG(val) (1 << (val))
+
+#define ALARMS_FROM_REG(val) val
+
+#define BEEP_ENABLE_TO_REG(val) ((val)?0:1)
+#define BEEP_ENABLE_FROM_REG(val) ((val)?0:1)
+
+#define BEEPS_TO_REG(val) (val)
+#define BEEPS_FROM_REG(val) (val)
+
+#define VID_FROM_REG(val) ((val)==0x1f?0:(val)>=0x10?510-(val)*10:\
+                           205-(val)*5)
+
+/* Each client has this additional data */
+struct gl520_data {
+       struct i2c_client client;
+       int sysctl_id;
+       enum chips type;
+
+       struct semaphore update_lock;
+       char valid;             /* !=0 if following fields are valid */
+       unsigned long last_updated;     /* In jiffies */
+
+       u8 voltage[5];          /* Register values; [0] = VDD */
+       u8 voltage_min[5];      /* Register values; [0] = VDD */
+       u8 voltage_max[5];      /* Register values; [0] = VDD */
+       u8 fan[2];
+       u8 fan_min[2];
+       u8 temp[2];             /* Register values */
+       u8 temp_over[2];        /* Register values */
+       u8 temp_hyst[2];        /* Register values */
+       u8 alarms, beeps, vid;  /* Register value */
+       u8 alarm_mask;          /* Register value */
+       u8 fan_div[2];          /* Register encoding, shifted right */
+       u8 beep_enable;         /* Boolean */
+       u8 two_temps;           /* Boolean */
+};
+
+static int gl520_attach_adapter(struct i2c_adapter *adapter);
+static int gl520_detect(struct i2c_adapter *adapter, int address,
+                       unsigned short flags, int kind);
+static void gl520_init_client(struct i2c_client *client);
+static int gl520_detach_client(struct i2c_client *client);
+
+static int gl520_read_value(struct i2c_client *client, u8 reg);
+static int gl520_write_value(struct i2c_client *client, u8 reg, u16 value);
+static void gl520_update_client(struct i2c_client *client);
+
+static void gl520_vin(struct i2c_client *client, int operation,
+                     int ctl_name, int *nrels_mag, long *results);
+static void gl520_vid(struct i2c_client *client, int operation,
+                     int ctl_name, int *nrels_mag, long *results);
+static void gl520_fan(struct i2c_client *client, int operation,
+                     int ctl_name, int *nrels_mag, long *results);
+static void gl520_temp(struct i2c_client *client, int operation,
+                      int ctl_name, int *nrels_mag, long *results);
+static void gl520_fan_div(struct i2c_client *client, int operation,
+                         int ctl_name, int *nrels_mag, long *results);
+static void gl520_alarms(struct i2c_client *client, int operation,
+                        int ctl_name, int *nrels_mag, long *results);
+static void gl520_beep(struct i2c_client *client, int operation,
+                      int ctl_name, int *nrels_mag, long *results);
+static void gl520_fan1off(struct i2c_client *client, int operation,
+                         int ctl_name, int *nrels_mag, long *results);
+static void gl520_config(struct i2c_client *client, int operation,
+                        int ctl_name, int *nrels_mag, long *results);
+
+/* This is the driver that will be inserted */
+static struct i2c_driver gl520_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "GL520SM sensor chip driver",
+       .id             = I2C_DRIVERID_GL520,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = gl520_attach_adapter,
+       .detach_client  = gl520_detach_client,
+};
+/* -- SENSORS SYSCTL START -- */
+
+#define GL520_SYSCTL_VDD  1000 /* Volts * 100 */
+#define GL520_SYSCTL_VIN1 1001
+#define GL520_SYSCTL_VIN2 1002
+#define GL520_SYSCTL_VIN3 1003
+#define GL520_SYSCTL_VIN4 1004
+#define GL520_SYSCTL_FAN1 1101 /* RPM */
+#define GL520_SYSCTL_FAN2 1102
+#define GL520_SYSCTL_TEMP1 1200        /* Degrees Celcius * 10 */
+#define GL520_SYSCTL_TEMP2 1201        /* Degrees Celcius * 10 */
+#define GL520_SYSCTL_VID 1300
+#define GL520_SYSCTL_FAN_DIV 2000      /* 1, 2, 4 or 8 */
+#define GL520_SYSCTL_ALARMS 2001       /* bitvector */
+#define GL520_SYSCTL_BEEP 2002 /* bitvector */
+#define GL520_SYSCTL_FAN1OFF 2003
+#define GL520_SYSCTL_CONFIG 2004
+
+#define GL520_ALARM_VDD 0x01
+#define GL520_ALARM_VIN1 0x02
+#define GL520_ALARM_VIN2 0x04
+#define GL520_ALARM_VIN3 0x08
+#define GL520_ALARM_TEMP1 0x10
+#define GL520_ALARM_FAN1 0x20
+#define GL520_ALARM_FAN2 0x40
+#define GL520_ALARM_TEMP2 0x80
+#define GL520_ALARM_VIN4 0x80
+
+/* -- SENSORS SYSCTL END -- */
+
+/* These files are created for each detected GL520. This is just a template;
+   though at first sight, you might think we could use a statically
+   allocated list, we need some way to get back to the parent - which
+   is done through one of the 'extra' fields which are initialized
+   when a new copy is allocated. */
+static ctl_table gl520_dir_table_template[] = {
+       {GL520_SYSCTL_VIN1, "vin1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &gl520_vin},
+       {GL520_SYSCTL_VIN2, "vin2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &gl520_vin},
+       {GL520_SYSCTL_VIN3, "vin3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &gl520_vin},
+       {GL520_SYSCTL_VIN4, "vin4", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &gl520_vin},
+       {GL520_SYSCTL_VDD, "vdd", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &gl520_vin},
+       {GL520_SYSCTL_VID, "vid", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &gl520_vid},
+       {GL520_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &gl520_fan},
+       {GL520_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &gl520_fan},
+       {GL520_SYSCTL_TEMP1, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &gl520_temp},
+       {GL520_SYSCTL_TEMP2, "temp2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &gl520_temp},
+       {GL520_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &gl520_fan_div},
+       {GL520_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &gl520_alarms},
+       {GL520_SYSCTL_BEEP, "beep", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &gl520_beep},
+       {GL520_SYSCTL_FAN1OFF, "fan1off", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &gl520_fan1off},
+       {GL520_SYSCTL_CONFIG, "config", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &gl520_config},
+       {0}
+};
+
+static int gl520_id = 0;
+
+static int gl520_attach_adapter(struct i2c_adapter *adapter)
+{
+       return i2c_detect(adapter, &addr_data, gl520_detect);
+}
+
+static int gl520_detect(struct i2c_adapter *adapter, int address,
+                       unsigned short flags, int kind)
+{
+       int i;
+       struct i2c_client *new_client;
+       struct gl520_data *data;
+       int err = 0;
+       const char *type_name = "";
+       char client_name[32];
+
+       /* Make sure we aren't probing the ISA bus!! This is just a safety check
+          at this moment; i2c_detect really won't call us. */
+#ifdef DEBUG
+       if (i2c_is_isa_adapter(adapter)) {
+               printk
+                   ("gl520sm.o: gl520_detect called for an ISA bus adapter?!?\n");
+               return 0;
+       }
+#endif
+
+       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
+                                    I2C_FUNC_SMBUS_WORD_DATA))
+                   goto ERROR0;
+
+       /* OK. For now, we presume we have a valid client. We now create the
+          client structure, even though we cannot fill it completely yet.
+          But it allows us to access gl520_{read,write}_value. */
+
+       if (!(data = kmalloc(sizeof(struct gl520_data), GFP_KERNEL))) {
+               err = -ENOMEM;
+               goto ERROR0;
+       }
+
+       new_client = &data->client;
+       new_client->addr = address;
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &gl520_driver;
+       new_client->flags = 0;
+
+       /* Determine the chip type. */
+
+       if (gl520_read_value(new_client, GL520_REG_CHIP_ID) != 0x20) {
+               printk
+                   ("gl520sm.o: Ignoring 'force' parameter for unknown chip at "
+                    "adapter %d, address 0x%02x\n",
+                    i2c_adapter_id(adapter), address);
+               goto ERROR1;
+       } else {
+               kind = gl520sm;
+       }
+
+       i = gl520_read_value(new_client, GL520_REG_REVISION);
+       if (kind == gl520sm) {
+               type_name = "gl520sm";
+               sprintf(client_name, "GL520SM Revision %02x chip", i);
+       } else {
+#ifdef DEBUG
+               printk("gl520sm.o: Internal error: unknown kind (%d)?!?",
+                      kind);
+#endif
+               goto ERROR1;
+       }
+
+       /* Fill in the remaining client fields and put it into the global list */
+       strcpy(new_client->name, client_name);
+       data->type = kind;
+
+       new_client->id = gl520_id++;
+       data->valid = 0;
+       init_MUTEX(&data->update_lock);
+
+       /* Tell the I2C layer a new client has arrived */
+       if ((err = i2c_attach_client(new_client)))
+               goto ERROR3;
+
+       /* Register a new directory entry with module sensors */
+       if ((i = i2c_register_entry(new_client,
+                                       type_name,
+                                       gl520_dir_table_template)) < 0) {
+               err = i;
+               goto ERROR4;
+       }
+       data->sysctl_id = i;
+
+       /* Initialize the GL520SM chip */
+       data->alarm_mask = 0xff;
+       gl520_init_client(new_client);
+       if (data->two_temps)
+               data->voltage_max[4] = data->voltage_min[4] =
+                       data->voltage[4] = 0;
+       else
+               data->temp_hyst[1] = data->temp_over[1] =
+                       data->temp[1] = 0;
+
+       return 0;
+
+/* OK, this is not exactly good programming practice, usually. But it is
+   very code-efficient in this case. */
+
+      ERROR4:
+       i2c_detach_client(new_client);
+      ERROR3:
+      ERROR1:
+       kfree(data);
+      ERROR0:
+       return err;
+}
+
+
+/* Called when we have found a new GL520SM. */
+static void gl520_init_client(struct i2c_client *client)
+{
+       struct gl520_data *data = (struct gl520_data *)(client->data);
+       u8 oldconf, conf;
+
+       conf = oldconf = gl520_read_value(client, GL520_REG_CONF);
+       data->two_temps = !(conf & 0x10);
+
+       /* If IRQ# is disabled, we can safely force comparator mode */
+       if (!(conf & 0x20))
+               conf &= 0xf7;
+
+       /* Enable monitoring if needed */
+       conf |= 0x40;
+
+       if (conf != oldconf)
+               gl520_write_value(client, GL520_REG_CONF, conf);
+}
+
+static int gl520_detach_client(struct i2c_client *client)
+{
+       int err;
+
+       i2c_deregister_entry(((struct gl520_data *) (client->data))->
+                                sysctl_id);
+
+       if ((err = i2c_detach_client(client))) {
+               printk
+                   ("gl520sm.o: Client deregistration failed, client not detached.\n");
+               return err;
+       }
+
+       kfree(client->data);
+
+       return 0;
+}
+
+
+/* Registers 0x07 to 0x0c are word-sized, others are byte-sized 
+   GL520 uses a high-byte first convention, which is exactly opposite to
+   the usual practice. */
+static int gl520_read_value(struct i2c_client *client, u8 reg)
+{
+       if ((reg >= 0x07) && (reg <= 0x0c))
+               return swab16(i2c_smbus_read_word_data(client, reg));
+       else
+               return i2c_smbus_read_byte_data(client, reg);
+}
+
+/* Registers 0x07 to 0x0c are word-sized, others are byte-sized 
+   GL520 uses a high-byte first convention, which is exactly opposite to
+   the usual practice. */
+static int gl520_write_value(struct i2c_client *client, u8 reg, u16 value)
+{
+       if ((reg >= 0x07) && (reg <= 0x0c))
+               return i2c_smbus_write_word_data(client, reg, swab16(value));
+       else
+               return i2c_smbus_write_byte_data(client, reg, value);
+}
+
+static void gl520_update_client(struct i2c_client *client)
+{
+       struct gl520_data *data = client->data;
+       int val;
+
+       down(&data->update_lock);
+
+       if ((jiffies - data->last_updated > HZ + HZ / 2) ||
+           (jiffies < data->last_updated) || !data->valid) {
+
+#ifdef DEBUG
+               printk("Starting gl520 update\n");
+#endif
+
+               data->alarms = gl520_read_value(client, GL520_REG_INT);
+               data->beeps = gl520_read_value(client, GL520_REG_ALARM);
+               data->vid = gl520_read_value(client, GL520_REG_VID) & 0x1f;
+
+               val = gl520_read_value(client, GL520_REG_VDD_LIMIT);
+               data->voltage_min[0] = val & 0xff;
+               data->voltage_max[0] = (val >> 8) & 0xff;
+               val = gl520_read_value(client, GL520_REG_VIN1_LIMIT);
+               data->voltage_min[1] = val & 0xff;
+               data->voltage_max[1] = (val >> 8) & 0xff;
+               val = gl520_read_value(client, GL520_REG_VIN2_LIMIT);
+               data->voltage_min[2] = val & 0xff;
+               data->voltage_max[2] = (val >> 8) & 0xff;
+               val = gl520_read_value(client, GL520_REG_VIN3_LIMIT);
+               data->voltage_min[3] = val & 0xff;
+               data->voltage_max[3] = (val >> 8) & 0xff;
+
+               val = gl520_read_value(client, GL520_REG_FAN_COUNT);
+               data->fan[0] = (val >> 8) & 0xff;
+               data->fan[1] = val & 0xff;
+
+               val = gl520_read_value(client, GL520_REG_FAN_LIMIT);
+               data->fan_min[0] = (val >> 8) & 0xff;
+               data->fan_min[1] = val & 0xff;
+
+               data->temp[0] = gl520_read_value(client, GL520_REG_TEMP1);
+               data->temp_over[0] =
+                   gl520_read_value(client, GL520_REG_TEMP1_OVER);
+               data->temp_hyst[0] =
+                   gl520_read_value(client, GL520_REG_TEMP1_HYST);
+
+               val = gl520_read_value(client, GL520_REG_MISC);
+               data->fan_div[0] = (val >> 6) & 0x03;
+               data->fan_div[1] = (val >> 4) & 0x03;
+
+               data->alarms &= data->alarm_mask;
+
+               val = gl520_read_value(client, GL520_REG_CONF);
+               data->beep_enable = (val >> 2) & 1;
+
+               data->voltage[0] = gl520_read_value(client, GL520_REG_VDD);
+               data->voltage[1] =
+                   gl520_read_value(client, GL520_REG_VIN1);
+               data->voltage[2] =
+                   gl520_read_value(client, GL520_REG_VIN2);
+               data->voltage[3] =
+                   gl520_read_value(client, GL520_REG_VIN3);
+
+               /* Temp1 and Vin4 are the same input */
+               if (data->two_temps) {
+                       data->temp[1] =
+                           gl520_read_value(client, GL520_REG_TEMP2);
+                       data->temp_over[1] =
+                           gl520_read_value(client, GL520_REG_TEMP2_OVER);
+                       data->temp_hyst[1] =
+                           gl520_read_value(client, GL520_REG_TEMP2_HYST);
+               } else {
+                       data->voltage[4] =
+                           gl520_read_value(client, GL520_REG_VIN4);
+                       data->voltage_min[4] =
+                           gl520_read_value(client, GL520_REG_VIN4_MIN);
+                       data->voltage_max[4] =
+                           gl520_read_value(client, GL520_REG_VIN4_MAX);
+               }
+
+               data->last_updated = jiffies;
+               data->valid = 1;
+       }
+
+       up(&data->update_lock);
+}
+
+void gl520_temp(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       struct gl520_data *data = client->data;
+       int nr = ctl_name - GL520_SYSCTL_TEMP1;
+       int regnr;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               gl520_update_client(client);
+               results[0] = TEMP_FROM_REG(data->temp_over[nr]);
+               results[1] = TEMP_FROM_REG(data->temp_hyst[nr]);
+               results[2] = TEMP_FROM_REG(data->temp[nr]);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if ((nr == 1) && (!data->two_temps))
+                       return;
+               regnr =
+                   nr == 0 ? GL520_REG_TEMP1_OVER : GL520_REG_TEMP2_OVER;
+               if (*nrels_mag >= 1) {
+                       data->temp_over[nr] = TEMP_TO_REG(results[0]);
+                       gl520_write_value(client, regnr,
+                                         data->temp_over[nr]);
+               }
+               regnr =
+                   nr == 0 ? GL520_REG_TEMP1_HYST : GL520_REG_TEMP2_HYST;
+               if (*nrels_mag >= 2) {
+                       data->temp_hyst[nr] = TEMP_TO_REG(results[1]);
+                       gl520_write_value(client, regnr,
+                                         data->temp_hyst[nr]);
+               }
+       }
+}
+
+void gl520_vin(struct i2c_client *client, int operation, int ctl_name,
+              int *nrels_mag, long *results)
+{
+       struct gl520_data *data = client->data;
+       int nr = ctl_name - GL520_SYSCTL_VDD;
+       int regnr, old = 0;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 2;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               gl520_update_client(client);
+               results[0] = nr ? IN_FROM_REG(data->voltage_min[nr]) :
+                   VDD_FROM_REG(data->voltage_min[nr]);
+               results[1] = nr ? IN_FROM_REG(data->voltage_max[nr]) :
+                   VDD_FROM_REG(data->voltage_max[nr]);
+               results[2] = nr ? IN_FROM_REG(data->voltage[nr]) :
+                   VDD_FROM_REG(data->voltage[nr]);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (nr != 4) {
+                       regnr =
+                           nr == 0 ? GL520_REG_VDD_LIMIT : nr ==
+                           1 ? GL520_REG_VIN1_LIMIT : nr ==
+                           2 ? GL520_REG_VIN2_LIMIT :
+                           GL520_REG_VIN3_LIMIT;
+                       if (*nrels_mag == 1)
+                               old =
+                                   gl520_read_value(client,
+                                                    regnr) & 0xff00;
+                       if (*nrels_mag >= 2) {
+                               data->voltage_max[nr] =
+                                   nr ? IN_TO_REG(results[1]) :
+                                   VDD_TO_REG(results[1]);
+                               old = data->voltage_max[nr] << 8;
+                       }
+                       if (*nrels_mag >= 1) {
+                               data->voltage_min[nr] =
+                                   nr ? IN_TO_REG(results[0]) :
+                                   VDD_TO_REG(results[0]);
+                               old |= data->voltage_min[nr];
+                               gl520_write_value(client, regnr, old);
+                       }
+               } else if (!data->two_temps) {
+                       if (*nrels_mag == 1)
+                               gl520_write_value(client,
+                                                 GL520_REG_VIN4_MIN,
+                                                 IN_TO_REG(results[0]));
+                       if (*nrels_mag >= 2)
+                               gl520_write_value(client,
+                                                 GL520_REG_VIN4_MAX,
+                                                 IN_TO_REG(results[1]));
+               }
+       }
+}
+
+
+void gl520_fan(struct i2c_client *client, int operation, int ctl_name,
+              int *nrels_mag, long *results)
+{
+       struct gl520_data *data = client->data;
+       int nr = ctl_name - GL520_SYSCTL_FAN1;
+       int old;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               gl520_update_client(client);
+               results[0] = FAN_FROM_REG(data->fan_min[nr],
+                                         DIV_FROM_REG(data->fan_div[nr]));
+               results[1] =
+                   FAN_FROM_REG(data->fan[nr],
+                                DIV_FROM_REG(data->fan_div[nr]));
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->fan_min[nr] = FAN_TO_REG(results[0],
+                                                      DIV_FROM_REG(data->
+                                                                   fan_div
+                                                                   [nr]));
+                       old =
+                           gl520_read_value(client, GL520_REG_FAN_LIMIT);
+
+                       if (nr == 0) {
+                               old =
+                                   (old & 0x00ff) | (data->
+                                                     fan_min[nr] << 8);
+                               if (results[0] == 0)
+                                       data->alarm_mask &= ~0x20;
+                               else
+                                       data->alarm_mask |= 0x20;
+                       } else {
+                               old = (old & 0xff00) | data->fan_min[nr];
+                               if (results[0] == 0)
+                                       data->alarm_mask &= ~0x40;
+                               else
+                                       data->alarm_mask |= 0x40;
+                       }
+                       gl520_write_value(client, GL520_REG_FAN_LIMIT,
+                                         old);
+               }
+       }
+}
+
+
+void gl520_alarms(struct i2c_client *client, int operation, int ctl_name,
+                 int *nrels_mag, long *results)
+{
+       struct gl520_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               gl520_update_client(client);
+               results[0] = ALARMS_FROM_REG(data->alarms);
+               *nrels_mag = 1;
+       }
+}
+
+void gl520_beep(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       struct gl520_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               gl520_update_client(client);
+               results[0] = BEEP_ENABLE_FROM_REG(data->beep_enable);
+               results[1] = BEEPS_FROM_REG(data->beeps);
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->beep_enable = BEEP_ENABLE_TO_REG(results[0]);
+                       gl520_write_value(client, GL520_REG_CONF,
+                                         (gl520_read_value(client,
+                                                           GL520_REG_CONF)
+                                          & 0xfb) | (data->
+                                                     beep_enable << 2));
+               }
+               if (*nrels_mag >= 2) {
+                       data->beeps =
+                           BEEPS_TO_REG(results[1]) & data->alarm_mask;
+                       gl520_write_value(client, GL520_REG_ALARM,
+                                         data->beeps);
+               }
+       }
+}
+
+
+void gl520_fan_div(struct i2c_client *client, int operation, int ctl_name,
+                  int *nrels_mag, long *results)
+{
+       struct gl520_data *data = client->data;
+       int old;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               gl520_update_client(client);
+               results[0] = DIV_FROM_REG(data->fan_div[0]);
+               results[1] = DIV_FROM_REG(data->fan_div[1]);
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               old = gl520_read_value(client, GL520_REG_MISC);
+               if (*nrels_mag >= 2) {
+                       data->fan_div[1] = DIV_TO_REG(results[1]);
+                       old = (old & 0xcf) | (data->fan_div[1] << 4);
+               }
+               if (*nrels_mag >= 1) {
+                       data->fan_div[0] = DIV_TO_REG(results[0]);
+                       old = (old & 0x3f) | (data->fan_div[0] << 6);
+               }
+               gl520_write_value(client, GL520_REG_MISC, old);
+       }
+}
+
+void gl520_vid(struct i2c_client *client, int operation, int ctl_name,
+              int *nrels_mag, long *results)
+{
+       struct gl520_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 2;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               gl520_update_client(client);
+               results[0] = VID_FROM_REG(data->vid);
+               *nrels_mag = 1;
+       }
+}
+
+void gl520_fan1off(struct i2c_client *client, int operation, int ctl_name,
+                  int *nrels_mag, long *results)
+{
+       int old;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               results[0] =
+                   ((gl520_read_value(client, GL520_REG_MISC) & 0x04) !=
+                    0);
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       old =
+                           gl520_read_value(client,
+                                            GL520_REG_MISC) & 0xfb;
+                       if (results[0])
+                               old |= 0x04;
+                       gl520_write_value(client, GL520_REG_MISC, old);
+               }
+       }
+}
+
+void gl520_config(struct i2c_client *client, int operation, int ctl_name,
+                 int *nrels_mag, long *results)
+{
+       struct gl520_data *data = client->data;
+       int old;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               results[0] =
+                   ((gl520_read_value(client, GL520_REG_CONF) & 0x10) ==
+                    0);
+               data->two_temps = results[0];
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       old =
+                           gl520_read_value(client,
+                                            GL520_REG_CONF) & 0xef;
+                       if (!results[1]) {
+                               old |= 0x10;
+                               data->two_temps = 0;
+                               data->temp_hyst[1] = data->temp_over[1] =
+                                       data->temp[1] = 0;
+                       } else {
+                               data->two_temps = 1;
+                               data->voltage_max[4] = data->voltage_min[4] =
+                                       data->voltage[4] = 0;
+                       }
+                       gl520_write_value(client, GL520_REG_CONF, old);
+               }
+       }
+}
+
+static int __init sm_gl520sm_init(void)
+{
+       printk("gl520sm.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       return i2c_add_driver(&gl520_driver);
+}
+
+static void __exit sm_gl520sm_exit(void)
+{
+       i2c_del_driver(&gl520_driver);
+}
+
+
+
+MODULE_AUTHOR
+    ("Frodo Looijaard <frodol@dds.nl> and Kyösti Mälkki <kmalkki@cc.hut.fi>");
+MODULE_DESCRIPTION("GL520SM driver");
+
+module_init(sm_gl520sm_init);
+module_exit(sm_gl520sm_exit);
--- linux-old/drivers/sensors/it87.c    Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/it87.c        Mon Dec 13 20:18:47 2004
@@ -0,0 +1,1128 @@
+/*
+    it87.c - Part of lm_sensors, Linux kernel modules for hardware
+             monitoring.
+
+    Supports: IT8705F  Super I/O chip w/LPC interface
+              IT8712F  Super I/O chup w/LPC interface & SMbus
+              Sis950   A clone of the IT8705F
+
+    Copyright (c) 2001 Chris Gauthron <chrisg@0-in.com> 
+    Largely inspired by lm78.c of the same package
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+    djg@pdp8.net 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.
+*/
+
+/*
+    michael.hufer@gmx.de Michael Hufer 09/07/03
+    Modified configure (enable/disable) chip reset at module load time.
+    Added ability to read and set fan pwm registers and the smart
+    guardian (sg) features of the chip.
+*/
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/ioport.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#include <asm/io.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+MODULE_LICENSE("GPL");
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = { SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { 0x20, 0x2f, SENSORS_I2C_END };
+static unsigned int normal_isa[] = { 0x0290, SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+/* Insmod parameters */
+SENSORS_INSMOD_4(it87, it8705, it8712, sis950);
+
+
+#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 */
+#define        DEVID   0x20    /* Register: Device ID */
+
+static inline void
+superio_outb(int reg, int val)
+{
+       outb(reg, REG);
+       outb(val, VAL);
+}
+
+static inline int
+superio_inb(int reg)
+{
+       outb(reg, REG);
+       return inb(VAL);
+}
+
+static inline void
+superio_select(void)
+{
+       outb(DEV, REG);
+       outb(PME, VAL);
+}
+
+static inline void
+superio_enter(void)
+{
+       outb(0x87, REG);
+       outb(0x01, REG);
+       outb(0x55, REG);
+       outb(0x55, REG);
+}
+
+static inline void
+superio_exit(void)
+{
+       outb(0x02, REG);
+       outb(0x02, VAL);
+}
+
+/* just IT8712F for now - this should be extended to support the other
+   chips as well */
+#define IT87_DEVID_MATCH(id) ((id) == 0x8712)
+
+#define IT87_ACT_REG  0x30
+#define IT87_BASE_REG 0x60
+
+/* Update battery voltage after every reading if true */
+static int update_vbat = 0;
+
+/* Reset the registers on init */
+static int reset = 0;
+
+/* 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
+
+/*----- The IT87 registers -----*/
+
+#define IT87_REG_CONFIG        0x00
+
+#define IT87_REG_ALARM1        0x01
+#define IT87_REG_ALARM2        0x02
+#define IT87_REG_ALARM3        0x03
+
+#define IT87_REG_VID           0x0a
+#define IT87_REG_FAN_DIV       0x0b
+
+#define IT87_REG_FAN(nr)       (0x0c + (nr))
+#define IT87_REG_FAN_MIN(nr)   (0x0f + (nr))
+#define IT87_REG_FAN_CTRL      0x13
+
+/* pwm and smart guardian registers */
+
+#define IT87_REG_FAN_ONOFF     0x14
+#define IT87_REG_PWM(nr)       (0x14 + (nr))
+#define IT87_REG_SG_TL_OFF(nr) (0x58 + (nr)*8)
+#define IT87_REG_SG_TL_LOW(nr) (0x59 + (nr)*8)
+#define IT87_REG_SG_TL_MED(nr) (0x5a + (nr)*8)
+#define IT87_REG_SG_TL_HI(nr)  (0x5b + (nr)*8)
+#define IT87_REG_SG_TL_OVR(nr) (0x5c + (nr)*8)
+#define IT87_REG_SG_PWM_LOW(nr) (0x5d + (nr)*8)
+#define IT87_REG_SG_PWM_MED(nr) (0x5e + (nr)*8)
+#define IT87_REG_SG_PWM_HI(nr)  (0x5f + (nr)*8)
+
+/* Monitors: 9 voltage (0 to 7, battery), 3 temp (1 to 3), 3 fan (1 to 3) */
+
+#define IT87_REG_VIN(nr)       (0x20 + (nr))
+#define IT87_REG_TEMP(nr)      (0x28 + (nr))
+
+#define IT87_REG_VIN_MAX(nr)   (0x30 + (nr) * 2)
+#define IT87_REG_VIN_MIN(nr)   (0x31 + (nr) * 2)
+#define IT87_REG_TEMP_HIGH(nr) (0x3e + (nr) * 2)
+#define IT87_REG_TEMP_LOW(nr)  (0x3f + (nr) * 2)
+
+#define IT87_REG_I2C_ADDR      0x48
+
+#define IT87_REG_VIN_ENABLE    0x50
+#define IT87_REG_TEMP_ENABLE   0x51
+
+#define IT87_REG_CHIPID        0x58
+
+/* sensor pin types */
+#define UNUSED         0
+#define THERMISTOR     2
+#define PIIDIODE       3
+
+/* Conversions. Limit checking is only done on the TO_REG 
+   variants. Note that you should be a bit careful with which arguments
+   these macros are called: arguments may be evaluated more than once.
+   Fixing this is just not worth it. */
+#define IN_TO_REG(val)  (SENSORS_LIMIT((((val) * 10 + 8)/16),0,255))
+#define IN_FROM_REG(val) (((val) *  16 + 5) / 10)
+
+static inline u8 FAN_TO_REG(long rpm, int div)
+{
+       if (rpm == 0)
+               return 255;
+       rpm = SENSORS_LIMIT(rpm, 1, 1000000);
+       return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1,
+                            254);
+}
+
+#define FAN_FROM_REG(val,div) ((val)==0?-1:(val)==255?0:1350000/((val)*(div)))
+
+#define TEMP_TO_REG(val) (SENSORS_LIMIT(((val)<0?(((val)-5)/10):\
+                                                 ((val)+5)/10),-127,127))
+#define TEMP_FROM_REG(val) (((val)>0x80?(val)-0x100:(val))*10)
+
+#define VID_FROM_REG(val) ((val)==0x1f?0:(val)>=0x10?510-(val)*10:\
+                           205-(val)*5)
+#define ALARMS_FROM_REG(val) (val)
+
+extern inline u8 DIV_TO_REG(long val)
+{
+       u8 i;
+       for( i = 0; i <= 7; i++ )
+       {
+               if( val>>i == 1 )
+                       return i;
+       }
+       return 1;
+}
+#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. */
+struct it87_data {
+       struct i2c_client client;
+       struct semaphore lock;
+       int sysctl_id;
+       enum chips type;
+
+       struct semaphore 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 fan_div[3];          /* Register encoding, shifted right */
+       u8 vid;                 /* Register encoding, combined */
+       u32 alarms;             /* Register encoding, combined */
+       u8 pwm[3];              /* Register value */
+       u8 fan_ctl[2];          /* Register encoding */
+       u8 sg_tl[3][5];         /* Register value */
+       u8 sg_pwm[3][3];        /* Register value */
+       u8 sens[3];             /* 2 = Thermistor,
+                                  3 = PII/Celeron diode */
+};
+
+
+static int it87_attach_adapter(struct i2c_adapter *adapter);
+static int it87_find(int *address);
+static int it87_detect(struct i2c_adapter *adapter, int address,
+                      unsigned short flags, int kind);
+static int it87_detach_client(struct i2c_client *client);
+
+static int it87_read_value(struct i2c_client *client, u8 register);
+static int it87_write_value(struct i2c_client *client, u8 register,
+                           u8 value);
+static void it87_update_client(struct i2c_client *client);
+static void it87_init_client(struct i2c_client *client);
+
+
+static void it87_in(struct i2c_client *client, int operation, int ctl_name,
+                   int *nrels_mag, long *results);
+static void it87_fan(struct i2c_client *client, int operation,
+                    int ctl_name, int *nrels_mag, long *results);
+static void it87_temp(struct i2c_client *client, int operation,
+                     int ctl_name, int *nrels_mag, long *results);
+static void it87_vid(struct i2c_client *client, int operation,
+                    int ctl_name, int *nrels_mag, long *results);
+static void it87_alarms(struct i2c_client *client, int operation,
+                           int ctl_name, int *nrels_mag, long *results);
+static void it87_fan_div(struct i2c_client *client, int operation,
+                        int ctl_name, int *nrels_mag, long *results);
+static void it87_fan_ctl(struct i2c_client *client, int operation,
+                        int ctl_name, int *nrels_mag, long *results);
+static void it87_pwm(struct i2c_client *client, int operation,
+                        int ctl_name, int *nrels_mag, long *results);
+static void it87_sgpwm(struct i2c_client *client, int operation,
+                        int ctl_name, int *nrels_mag, long *results);
+static void it87_sgtl(struct i2c_client *client, int operation,
+                        int ctl_name, int *nrels_mag, long *results);
+static void it87_sens(struct i2c_client *client, int operation,
+                        int ctl_name, int *nrels_mag, long *results);
+
+static struct i2c_driver it87_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "IT87xx sensor driver",
+       .id             = I2C_DRIVERID_IT87,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = it87_attach_adapter,
+       .detach_client  = it87_detach_client,
+};
+
+static int it87_id = 0;
+
+/* The /proc/sys entries */
+
+/* -- SENSORS SYSCTL START -- */
+#define IT87_SYSCTL_IN0 1000    /* Volts * 100 */
+#define IT87_SYSCTL_IN1 1001
+#define IT87_SYSCTL_IN2 1002
+#define IT87_SYSCTL_IN3 1003
+#define IT87_SYSCTL_IN4 1004
+#define IT87_SYSCTL_IN5 1005
+#define IT87_SYSCTL_IN6 1006
+#define IT87_SYSCTL_IN7 1007
+#define IT87_SYSCTL_IN8 1008
+#define IT87_SYSCTL_FAN1 1101   /* Rotations/min */
+#define IT87_SYSCTL_FAN2 1102
+#define IT87_SYSCTL_FAN3 1103
+#define IT87_SYSCTL_TEMP1 1200  /* Degrees Celcius * 10 */
+#define IT87_SYSCTL_TEMP2 1201  /* Degrees Celcius * 10 */
+#define IT87_SYSCTL_TEMP3 1202  /* Degrees Celcius * 10 */
+#define IT87_SYSCTL_VID 1300    /* Volts * 100 */
+#define IT87_SYSCTL_FAN_DIV 2000        /* 1, 2, 4 or 8 */
+#define IT87_SYSCTL_ALARMS 2004    /* bitvector */
+
+#define IT87_SYSCTL_PWM1 1401
+#define IT87_SYSCTL_PWM2 1402
+#define IT87_SYSCTL_PWM3 1403
+#define IT87_SYSCTL_FAN_CTL  1501
+#define IT87_SYSCTL_FAN_ON_OFF  1502
+#define IT87_SYSCTL_SENS1 1601 /* 1, 2, or Beta (3000-5000) */
+#define IT87_SYSCTL_SENS2 1602
+#define IT87_SYSCTL_SENS3 1603
+
+#define IT87_ALARM_IN0 0x000100
+#define IT87_ALARM_IN1 0x000200
+#define IT87_ALARM_IN2 0x000400
+#define IT87_ALARM_IN3 0x000800
+#define IT87_ALARM_IN4 0x001000
+#define IT87_ALARM_IN5 0x002000
+#define IT87_ALARM_IN6 0x004000
+#define IT87_ALARM_IN7 0x008000
+#define IT87_ALARM_FAN1 0x0001
+#define IT87_ALARM_FAN2 0x0002
+#define IT87_ALARM_FAN3 0x0004
+#define IT87_ALARM_TEMP1 0x00010000
+#define IT87_ALARM_TEMP2 0x00020000
+#define IT87_ALARM_TEMP3 0x00040000
+
+/* -- SENSORS SYSCTL END -- */
+
+/* These files are created for each detected IT87. This is just a template;
+   though at first sight, you might think we could use a statically
+   allocated list, we need some way to get back to the parent - which
+   is done through one of the 'extra' fields which are initialized 
+   when a new copy is allocated. */
+static ctl_table it87_dir_table_template[] = {
+       {IT87_SYSCTL_IN0, "in0", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &it87_in},
+       {IT87_SYSCTL_IN1, "in1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &it87_in},
+       {IT87_SYSCTL_IN2, "in2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &it87_in},
+       {IT87_SYSCTL_IN3, "in3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &it87_in},
+       {IT87_SYSCTL_IN4, "in4", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &it87_in},
+       {IT87_SYSCTL_IN5, "in5", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &it87_in},
+       {IT87_SYSCTL_IN6, "in6", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &it87_in},
+       {IT87_SYSCTL_IN7, "in7", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &it87_in},
+       {IT87_SYSCTL_IN8, "in8", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &it87_in},
+       {IT87_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &it87_fan},
+       {IT87_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &it87_fan},
+       {IT87_SYSCTL_FAN3, "fan3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &it87_fan},
+       {IT87_SYSCTL_TEMP1, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &it87_temp},
+       {IT87_SYSCTL_TEMP2, "temp2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &it87_temp},
+       {IT87_SYSCTL_TEMP3, "temp3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &it87_temp},
+       {IT87_SYSCTL_VID, "vid", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &it87_vid},
+       {IT87_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &it87_fan_div},
+       {IT87_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &it87_alarms},
+       {IT87_SYSCTL_FAN_CTL, "fan_ctl", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &it87_fan_ctl},
+       {IT87_SYSCTL_FAN_ON_OFF, "fan_on_off", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &it87_fan_ctl},
+       {IT87_SYSCTL_PWM1, "pwm1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &it87_pwm},
+       {IT87_SYSCTL_PWM2, "pwm2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &it87_pwm},
+       {IT87_SYSCTL_PWM3, "pwm3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &it87_pwm},
+       {IT87_SYSCTL_PWM1, "sg_pwm1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &it87_sgpwm},
+       {IT87_SYSCTL_PWM2, "sg_pwm2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &it87_sgpwm},
+       {IT87_SYSCTL_PWM3, "sg_pwm3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &it87_sgpwm},
+       {IT87_SYSCTL_PWM1, "sg_tl1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &it87_sgtl},
+       {IT87_SYSCTL_PWM2, "sg_tl2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &it87_sgtl},
+       {IT87_SYSCTL_PWM3, "sg_tl3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &it87_sgtl},
+       {IT87_SYSCTL_SENS1, "sensor1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &it87_sens},
+       {IT87_SYSCTL_SENS2, "sensor2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &it87_sens},
+       {IT87_SYSCTL_SENS3, "sensor3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &it87_sens},
+       {0}
+};
+
+
+/* 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)
+{
+       return i2c_detect(adapter, &addr_data, it87_detect);
+}
+
+static int it87_find(int *address)
+{
+       u16 val;
+
+       superio_enter();
+       val = (superio_inb(DEVID) << 8) |
+              superio_inb(DEVID + 1);
+       if (!IT87_DEVID_MATCH(val)) {
+               superio_exit();
+               return -ENODEV;
+       }
+
+       superio_select();
+       val = (superio_inb(IT87_BASE_REG) << 8) |
+              superio_inb(IT87_BASE_REG + 1);
+       superio_exit();
+       *address = val & ~(IT87_EXTENT - 1);
+       if (*address == 0) {
+               return -ENODEV;
+       }
+       return 0;
+}
+
+/* This function is called by i2c_detect */
+int it87_detect(struct i2c_adapter *adapter, int address,
+               unsigned short flags, int kind)
+{
+       int i;
+       struct i2c_client *new_client;
+       struct it87_data *data;
+       int err = 0;
+       const char *type_name = "";
+       const char *client_name = "";
+       int is_isa = i2c_is_isa_adapter(adapter);
+
+       if (!is_isa
+        && !i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
+               return 0;
+
+       if (is_isa
+        && check_region(address, IT87_EXTENT))
+               return 0;
+
+       /* Probe whether there is anything available on this address. Already
+          done for SMBus clients */
+       if (is_isa && kind < 0) {
+#define REALLY_SLOW_IO
+               /* We need the timeouts for at least some IT87-like chips.
+                  But only if we read 'undefined' registers. */
+               i = inb_p(address + 1);
+               if (inb_p(address + 2) != i
+                || inb_p(address + 3) != i
+                || inb_p(address + 7) != i)
+                       return -ENODEV;
+#undef REALLY_SLOW_IO
+
+               /* Let's just hope nothing breaks here */
+               i = inb_p(address + 5) & 0x7f;
+               outb_p(~i & 0x7f, address + 5);
+               if ((inb_p(address + 5) & 0x7f) != (~i & 0x7f)) {
+                       outb_p(i, address + 5);
+                       return -ENODEV;
+               }
+       }
+
+       /* OK. For now, we presume we have a valid client. We now create the
+          client structure, even though we cannot fill it completely yet.
+          But it allows us to access it87_{read,write}_value. */
+
+       if (!(data = kmalloc(sizeof(struct it87_data), GFP_KERNEL))) {
+               err = -ENOMEM;
+               goto ERROR0;
+       }
+
+       new_client = &data->client;
+       if (is_isa)
+               init_MUTEX(&data->lock);
+       new_client->addr = address;
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &it87_driver;
+       new_client->flags = 0;
+
+       /* 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 ERROR1;
+               }
+       }
+
+       /* Determine the chip type. */
+       if (kind <= 0) {
+               i = it87_read_value(new_client, IT87_REG_CHIPID);
+               if (i == 0x90) {
+                       kind = it87;
+               }
+               else {
+                       if (kind == 0)
+                               printk
+                                   ("it87.o: Ignoring 'force' parameter for unknown chip at "
+                                    "adapter %d, address 0x%02x\n",
+                                    i2c_adapter_id(adapter), address);
+                       err = -ENODEV;
+                       goto ERROR1;
+               }
+       }
+
+       if (kind == it87) {
+               type_name = "it87";
+               client_name = "IT87 chip";
+       } /* else if (kind == it8712) {
+               type_name = "it8712";
+               client_name = "IT87-J chip";
+       } */ else {
+#ifdef DEBUG
+               printk("it87.o: Internal error: unknown kind (%d)?!?",
+                      kind);
+#endif
+               goto ERROR1;
+       }
+
+       /* Reserve the ISA region */
+       if (is_isa)
+               request_region(address, IT87_EXTENT, type_name);
+
+       /* Fill in the remaining client fields and put it into the global list */
+       strcpy(new_client->name, client_name);
+       data->type = kind;
+
+       new_client->id = it87_id++;
+       data->valid = 0;
+       init_MUTEX(&data->update_lock);
+
+       /* Tell the I2C layer a new client has arrived */
+       if ((err = i2c_attach_client(new_client)))
+               goto ERROR3;
+
+       /* Register a new directory entry with module sensors */
+       if ((i = i2c_register_entry(new_client,
+                                   type_name,
+                                   it87_dir_table_template)) < 0) {
+               err = i;
+               goto ERROR4;
+       }
+       data->sysctl_id = i;
+
+       /* Initialize the IT87 chip */
+       it87_init_client(new_client);
+       return 0;
+
+/* OK, this is not exactly good programming practice, usually. But it is
+   very code-efficient in this case. */
+
+      ERROR4:
+       i2c_detach_client(new_client);
+      ERROR3:
+       if (is_isa)
+               release_region(address, IT87_EXTENT);
+      ERROR1:
+       kfree(data);
+      ERROR0:
+       return err;
+}
+
+static int it87_detach_client(struct i2c_client *client)
+{
+       int err;
+
+       i2c_deregister_entry(((struct it87_data *) (client->data))->
+                               sysctl_id);
+
+       if ((err = i2c_detach_client(client))) {
+               printk
+                   ("it87.o: Client deregistration failed, client not detached.\n");
+               return err;
+       }
+
+       if(i2c_is_isa_client(client))
+               release_region(client->addr, IT87_EXTENT);
+       kfree(client->data);
+
+       return 0;
+}
+
+/* The SMBus locks itself, but ISA access must be locked explicitely! 
+   We don't want to lock the whole ISA bus, so we lock each client
+   separately.
+   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. 
+   There are some ugly typecasts here, but the good new is - they should
+   nowhere else be necessary! */
+static int it87_read_value(struct i2c_client *client, u8 reg)
+{
+       int res;
+       if (i2c_is_isa_client(client)) {
+               down(&(((struct it87_data *) (client->data))->lock));
+               outb_p(reg, client->addr + IT87_ADDR_REG_OFFSET);
+               res = inb_p(client->addr + IT87_DATA_REG_OFFSET);
+               up(&(((struct it87_data *) (client->data))->lock));
+               return res;
+       } else
+               return i2c_smbus_read_byte_data(client, reg);
+}
+
+/* The SMBus locks itself, but ISA access muse be locked explicitely! 
+   We don't want to lock the whole ISA bus, so we lock each client
+   separately.
+   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. 
+   There are some ugly typecasts here, but the good new is - they should
+   nowhere else be necessary! */
+static int it87_write_value(struct i2c_client *client, u8 reg, u8 value)
+{
+       if (i2c_is_isa_client(client)) {
+               down(&(((struct it87_data *) (client->data))->lock));
+               outb_p(reg, client->addr + IT87_ADDR_REG_OFFSET);
+               outb_p(value, client->addr + IT87_DATA_REG_OFFSET);
+               up(&(((struct it87_data *) (client->data))->lock));
+               return 0;
+       } else
+               return i2c_smbus_write_byte_data(client, reg, value);
+}
+
+/* Called when we have found a new IT87. */
+static void it87_init_client(struct i2c_client *client)
+{
+       int tmp;
+
+       if (reset) {
+               /* Reset all except Watchdog values and last conversion values
+                  This sets fan-divs to 2, among others */
+               it87_write_value(client, IT87_REG_CONFIG, 0x80);
+       }
+
+       /* Check if temperature channnels are reset manually or by some reason */
+       tmp = it87_read_value(client, 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);
+       }
+
+       /* Check if voltage monitors are reset manually or by some reason */
+       tmp = it87_read_value(client, IT87_REG_VIN_ENABLE);
+       if ((tmp & 0xff) == 0) {
+               /* Enable all voltage monitors */
+               it87_write_value(client, IT87_REG_VIN_ENABLE, 0xff);
+       }
+
+       /* Check if tachometers are reset manually or by some reason */
+       tmp = it87_read_value(client, IT87_REG_FAN_CTRL);
+       if ((tmp & 0x70) == 0) {
+               /* Enable all fan tachometers */
+               tmp = (tmp & 0x8f) | 0x70;
+               it87_write_value(client, IT87_REG_FAN_CTRL, tmp);
+       }
+
+       /* Start monitoring */
+       it87_write_value(client, IT87_REG_CONFIG,
+                        (it87_read_value(client, IT87_REG_CONFIG) & 0x36)
+                        | (update_vbat ? 0x41 : 0x01));
+}
+
+static void it87_update_client(struct i2c_client *client)
+{
+       struct it87_data *data = client->data;
+       int i, tmp, tmp2;
+
+       down(&data->update_lock);
+
+       if ((jiffies - data->last_updated > HZ + HZ / 2) ||
+           (jiffies < data->last_updated) || !data->valid) {
+
+               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);
+               }
+               for (i = 0; i <= 7; i++) {
+                       data->in[i] =
+                           it87_read_value(client, IT87_REG_VIN(i));
+                       data->in_min[i] =
+                           it87_read_value(client, IT87_REG_VIN_MIN(i));
+                       data->in_max[i] =
+                           it87_read_value(client, IT87_REG_VIN_MAX(i));
+               }
+               data->in[8] =
+                   it87_read_value(client, IT87_REG_VIN(8));
+               /* VBAT sensor doesn't have limit registers, set
+                  to min and max value */
+               data->in_min[8] = 0;
+               data->in_max[8] = 255;
+                
+               for (i = 1; i <= 3; i++) {
+                       data->fan[i - 1] =
+                           it87_read_value(client, IT87_REG_FAN(i));
+                       data->fan_min[i - 1] =
+                           it87_read_value(client, IT87_REG_FAN_MIN(i));
+               }
+               for (i = 1; i <= 3; i++) {
+                       data->temp[i - 1] =
+                           it87_read_value(client, IT87_REG_TEMP(i));
+                       data->temp_high[i - 1] =
+                           it87_read_value(client, IT87_REG_TEMP_HIGH(i));
+                       data->temp_low[i - 1] =
+                           it87_read_value(client, IT87_REG_TEMP_LOW(i));
+               }
+
+               /* The 8705 does not have VID capability */
+               /*if (data->type == it8712) {
+                       data->vid = it87_read_value(client, IT87_REG_VID);
+                       data->vid &= 0x1f;
+               }
+               else */ {
+                       data->vid = 0x1f;
+               }
+
+               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)==0x40 ? 3 : 1 );
+
+               for( i = 1; i <= 3; i++ ) {
+                       data->pwm[i-1] = it87_read_value(client, IT87_REG_PWM(i));
+                       data->sg_tl[i-1][0] = it87_read_value(client, IT87_REG_SG_TL_OFF(i));
+                       data->sg_tl[i-1][1] = it87_read_value(client, IT87_REG_SG_TL_LOW(i));
+                       data->sg_tl[i-1][2] = it87_read_value(client, IT87_REG_SG_TL_MED(i));
+                       data->sg_tl[i-1][3] = it87_read_value(client, IT87_REG_SG_TL_HI(i));
+                       data->sg_tl[i-1][4] = it87_read_value(client, IT87_REG_SG_TL_OVR(i));
+                       data->sg_pwm[i-1][0] = it87_read_value(client, IT87_REG_SG_PWM_LOW(i));
+                       data->sg_pwm[i-1][1] = it87_read_value(client, IT87_REG_SG_PWM_MED(i));
+                       data->sg_pwm[i-1][2] = it87_read_value(client, IT87_REG_SG_PWM_HI(i));
+               }
+               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_ctl[0] = it87_read_value(client, IT87_REG_FAN_CTRL);
+               data->fan_ctl[1] = it87_read_value(client, IT87_REG_FAN_ONOFF);
+
+               tmp = it87_read_value(client, IT87_REG_TEMP_ENABLE);
+               for(i = 0; i < 3; i++) {
+                       tmp2 = (tmp >> i) & 0x09;
+                       if(tmp2 == 0x01)
+                               data->sens[i] = PIIDIODE;
+                       else if(tmp2 == 0x08)
+                               data->sens[i] = THERMISTOR;
+                       else
+                               data->sens[i] = UNUSED;
+               }
+
+               data->last_updated = jiffies;
+               data->valid = 1;
+       }
+
+       up(&data->update_lock);
+}
+
+
+/* The next few functions are the call-back functions of the /proc/sys and
+   sysctl files. Which function is used is defined in the ctl_table in
+   the extra1 field.
+    - Each function must return the magnitude (power of 10 to divide the
+      data with) if it is called with operation==SENSORS_PROC_REAL_INFO.
+    - It must put a maximum of *nrels elements in results reflecting the
+      data of this file, and set *nrels to the number it actually put 
+      in it, if operation==SENSORS_PROC_REAL_READ.
+    - Finally, it must get upto *nrels elements from results and write them
+      to the chip, if operations==SENSORS_PROC_REAL_WRITE.
+   Note that on SENSORS_PROC_REAL_READ, I do not check whether results is
+   large enough (by checking the incoming value of *nrels). This is not very
+   good practice, but as long as you put less than about 5 values in results,
+   you can assume it is large enough. */
+void it87_in(struct i2c_client *client, int operation, int ctl_name,
+            int *nrels_mag, long *results)
+{
+       struct it87_data *data = client->data;
+       int nr = ctl_name - IT87_SYSCTL_IN0;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 2;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               it87_update_client(client);
+               results[0] = IN_FROM_REG(data->in_min[nr]);
+               results[1] = IN_FROM_REG(data->in_max[nr]);
+               results[2] = IN_FROM_REG(data->in[nr]);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->in_min[nr] = IN_TO_REG(results[0]);
+                       it87_write_value(client, IT87_REG_VIN_MIN(nr),
+                                        data->in_min[nr]);
+               }
+               if (*nrels_mag >= 2) {
+                       data->in_max[nr] = IN_TO_REG(results[1]);
+                       it87_write_value(client, IT87_REG_VIN_MAX(nr),
+                                        data->in_max[nr]);
+               }
+       }
+}
+
+void it87_fan(struct i2c_client *client, int operation, int ctl_name,
+             int *nrels_mag, long *results)
+{
+       struct it87_data *data = client->data;
+       int nr = ctl_name - IT87_SYSCTL_FAN1 + 1;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               it87_update_client(client);
+               results[0] = FAN_FROM_REG(data->fan_min[nr - 1],
+                                         DIV_FROM_REG(data->fan_div[nr - 1]));
+               results[1] = FAN_FROM_REG(data->fan[nr - 1],
+                                DIV_FROM_REG(data->fan_div[nr - 1]));
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->fan_min[nr - 1] = FAN_TO_REG(results[0],
+                                                          DIV_FROM_REG(data->fan_div[nr - 1]));
+                       it87_write_value(client, IT87_REG_FAN_MIN(nr),
+                                        data->fan_min[nr - 1]);
+               }
+       }
+}
+
+
+void it87_temp(struct i2c_client *client, int operation, int ctl_name,
+              int *nrels_mag, long *results)
+{
+       struct it87_data *data = client->data;
+       int nr = ctl_name - IT87_SYSCTL_TEMP1 + 1;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               it87_update_client(client);
+               results[0] = TEMP_FROM_REG(data->temp_high[nr - 1]);
+               results[1] = TEMP_FROM_REG(data->temp_low[nr - 1]);
+               results[2] = TEMP_FROM_REG(data->temp[nr - 1]);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->temp_high[nr - 1] = TEMP_TO_REG(results[0]);
+                       it87_write_value(client, IT87_REG_TEMP_HIGH(nr),
+                                        data->temp_high[nr - 1]);
+               }
+               if (*nrels_mag >= 2) {
+                       data->temp_low[nr - 1] = TEMP_TO_REG(results[1]);
+                       it87_write_value(client, IT87_REG_TEMP_LOW(nr),
+                                        data->temp_low[nr - 1]);
+               }
+       }
+}
+
+void it87_pwm(struct i2c_client *client, int operation, int ctl_name,
+              int *nrels_mag, long *results)
+{
+       struct it87_data *data = client->data;
+       int nr = ctl_name - IT87_SYSCTL_PWM1 + 1;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               it87_update_client(client);
+               results[0] = data->pwm[nr - 1];
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->pwm[nr - 1] = results[0];
+                       it87_write_value(client, IT87_REG_PWM(nr), data->pwm[nr - 1]);
+               }
+       }
+}
+
+void it87_sgpwm(struct i2c_client *client, int operation, int ctl_name,
+              int *nrels_mag, long *results)
+{
+       struct it87_data *data = client->data;
+       int nr = ctl_name - IT87_SYSCTL_PWM1 + 1;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               it87_update_client(client);
+               results[0] = data->sg_pwm[nr - 1][0];
+               results[1] = data->sg_pwm[nr - 1][1];
+               results[2] = data->sg_pwm[nr - 1][2];
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->sg_pwm[nr - 1][0] = results[0];
+                       it87_write_value(client, IT87_REG_SG_PWM_LOW(nr), data->sg_pwm[nr - 1][0]);
+               }
+               if (*nrels_mag >= 2) {
+                       data->sg_pwm[nr - 1][1] = results[1];
+                       it87_write_value(client, IT87_REG_SG_PWM_MED(nr), data->sg_pwm[nr - 1][1]);
+               }
+               if (*nrels_mag >= 3) {
+                       data->sg_pwm[nr - 1][2] = results[2];
+                       it87_write_value(client, IT87_REG_SG_PWM_HI(nr), data->sg_pwm[nr - 1][2]);
+               }
+       }
+}
+
+void it87_sgtl(struct i2c_client *client, int operation, int ctl_name,
+              int *nrels_mag, long *results)
+{
+       struct it87_data *data = client->data;
+       int nr = ctl_name - IT87_SYSCTL_PWM1 + 1;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               it87_update_client(client);
+               results[0] = TEMP_FROM_REG(data->sg_tl[nr - 1][0]);
+               results[1] = TEMP_FROM_REG(data->sg_tl[nr - 1][1]);
+               results[2] = TEMP_FROM_REG(data->sg_tl[nr - 1][2]);
+               results[3] = TEMP_FROM_REG(data->sg_tl[nr - 1][3]);
+               results[4] = TEMP_FROM_REG(data->sg_tl[nr - 1][4]);
+               *nrels_mag = 5;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->sg_tl[nr - 1][0] = TEMP_TO_REG(results[0]);
+                       it87_write_value(client, IT87_REG_SG_TL_OFF(nr), data->sg_tl[nr - 1][0]);
+               }
+               if (*nrels_mag >= 2) {
+                       data->sg_tl[nr - 1][1] = TEMP_TO_REG(results[1]);
+                       it87_write_value(client, IT87_REG_SG_TL_LOW(nr), data->sg_tl[nr - 1][1]);
+               }
+               if (*nrels_mag >= 3) {
+                       data->sg_tl[nr - 1][2] = TEMP_TO_REG(results[2]);
+                       it87_write_value(client, IT87_REG_SG_TL_MED(nr), data->sg_tl[nr - 1][2]);
+               }
+               if (*nrels_mag >= 4) {
+                       data->sg_tl[nr - 1][3] = TEMP_TO_REG(results[3]);
+                       it87_write_value(client, IT87_REG_SG_TL_HI(nr), data->sg_tl[nr - 1][3]);
+               }
+               if (*nrels_mag >= 5) {
+                       data->sg_tl[nr - 1][4] = TEMP_TO_REG(results[4]);
+                       it87_write_value(client, IT87_REG_SG_TL_OVR(nr), data->sg_tl[nr - 1][4]);
+               }
+       }
+}
+
+void it87_vid(struct i2c_client *client, int operation, int ctl_name,
+             int *nrels_mag, long *results)
+{
+       struct it87_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 2;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               it87_update_client(client);
+               results[0] = VID_FROM_REG(data->vid);
+               *nrels_mag = 1;
+       }
+}
+
+void it87_alarms(struct i2c_client *client, int operation,
+                     int ctl_name, int *nrels_mag, long *results)
+{
+       struct it87_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               it87_update_client(client);
+               results[0] = ALARMS_FROM_REG(data->alarms);
+               *nrels_mag = 1;
+       }
+}
+
+void it87_fan_div(struct i2c_client *client, int operation, int ctl_name,
+                 int *nrels_mag, long *results)
+{
+       struct it87_data *data = client->data;
+       int old;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               it87_update_client(client);
+               results[0] = DIV_FROM_REG(data->fan_div[0]);
+               results[1] = DIV_FROM_REG(data->fan_div[1]);
+               results[2] = DIV_FROM_REG(data->fan_div[2]);;
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               old = it87_read_value(client, IT87_REG_FAN_DIV);
+               if (*nrels_mag >= 3) {
+                       data->fan_div[2] = DIV_TO_REG(results[2]);
+                       if( data->fan[2]!=3 ) {
+                               data->fan_div[2] = 1;
+                               old = (old & 0xbf);
+                       } else {
+                               old = (old | 0x40);
+                       }
+               }
+               if (*nrels_mag >= 2) {
+                       data->fan_div[1] = DIV_TO_REG(results[1]);
+                       old = (old & 0xc3) | (data->fan_div[1] << 3);
+               }
+               if (*nrels_mag >= 1) {
+                       data->fan_div[0] = DIV_TO_REG(results[0]);
+                       old = (old & 0xf8) | data->fan_div[0];
+                       it87_write_value(client, IT87_REG_FAN_DIV, old);
+               }
+       }
+}
+
+void it87_fan_ctl(struct i2c_client *client, int operation, int ctl_name,
+              int *nrels_mag, long *results)
+{
+       struct it87_data *data = client->data;
+       int index = ctl_name - IT87_SYSCTL_FAN_CTL;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               it87_update_client(client);
+               results[0] = data->fan_ctl[index];
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->fan_ctl[index] = results[0];
+                       if( index == 0 )
+                               it87_write_value(client, IT87_REG_FAN_CTRL, data->fan_ctl[index] );
+                       else
+                               it87_write_value(client, IT87_REG_FAN_ONOFF, data->fan_ctl[index] );
+               }
+       }
+}
+
+void it87_sens(struct i2c_client *client, int operation, int ctl_name,
+                 int *nrels_mag, long *results)
+{
+       struct it87_data *data = client->data;
+       int nr = 1 + ctl_name - IT87_SYSCTL_SENS1;
+       u8 tmp, val1, val2;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               results[0] = data->sens[nr - 1];
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       val1 = 0x01 << (nr - 1);
+                       val2 = 0x08 << (nr - 1);
+                       tmp = it87_read_value(client, IT87_REG_TEMP_ENABLE);
+                       switch (results[0]) {
+                       case PIIDIODE:
+                               tmp &= ~ val2;
+                               tmp |= val1;
+                               break;
+                       case THERMISTOR:
+                               tmp &= ~ val1;
+                               tmp |= val2;
+                               break;
+                       case UNUSED:
+                               tmp &= ~ val1;
+                               tmp &= ~ val2;
+                               break;
+                       default:
+                               printk(KERN_ERR "it87.o: Invalid sensor type %ld; "
+                                      "must be 0 (unused), 2 (thermistor) "
+                                      "or 3 (diode)\n", results[0]);
+                               return;
+                       }
+                       it87_write_value(client,
+                                        IT87_REG_TEMP_ENABLE, tmp);
+                       data->sens[nr - 1] = results[0];
+               }
+       }
+}
+
+static int __init sm_it87_init(void)
+{
+       int addr;
+
+       printk("it87.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       if (!it87_find(&addr)) {
+               normal_isa[0] = addr;
+       }
+       return i2c_add_driver(&it87_driver);
+}
+
+static void __exit sm_it87_exit(void)
+{
+       i2c_del_driver(&it87_driver);
+}
+
+
+
+MODULE_AUTHOR("Chris Gauthron <chrisg@0-in.com>");
+MODULE_DESCRIPTION("IT8705F, IT8712F, Sis950 driver");
+MODULE_PARM(update_vbat, "i");
+MODULE_PARM_DESC(update_vbat, "Update vbat if set else return powerup value");
+MODULE_PARM(reset, "i");
+MODULE_PARM_DESC(reset, "Reset the chip's registers, default no");
+
+module_init(sm_it87_init);
+module_exit(sm_it87_exit);
--- linux-old/drivers/sensors/lm75.c    Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/lm75.c        Mon Dec 13 20:18:47 2004
@@ -0,0 +1,331 @@
+/*
+    lm75.c - Part of lm_sensors, Linux kernel modules for hardware
+             monitoring
+    Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+#include "lm75.h"
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = { SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { 0x48, 0x4f, SENSORS_I2C_END };
+static unsigned int normal_isa[] = { SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+/* Insmod parameters */
+SENSORS_INSMOD_1(lm75);
+
+/* Many LM75 constants specified below */
+
+/* The LM75 registers */
+#define LM75_REG_TEMP 0x00
+#define LM75_REG_CONF 0x01
+#define LM75_REG_TEMP_HYST 0x02
+#define LM75_REG_TEMP_OS 0x03
+
+/* Each client has this additional data */
+struct lm75_data {
+       struct i2c_client client;
+       int sysctl_id;
+
+       struct semaphore update_lock;
+       char valid;             /* !=0 if following fields are valid */
+       unsigned long last_updated;     /* In jiffies */
+
+       u16 temp, temp_os, temp_hyst;   /* Register values */
+};
+
+static int lm75_attach_adapter(struct i2c_adapter *adapter);
+static int lm75_detect(struct i2c_adapter *adapter, int address,
+                      unsigned short flags, int kind);
+static void lm75_init_client(struct i2c_client *client);
+static int lm75_detach_client(struct i2c_client *client);
+
+static int lm75_read_value(struct i2c_client *client, u8 reg);
+static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value);
+static void lm75_temp(struct i2c_client *client, int operation,
+                     int ctl_name, int *nrels_mag, long *results);
+static void lm75_update_client(struct i2c_client *client);
+
+
+/* This is the driver that will be inserted */
+static struct i2c_driver lm75_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "LM75 sensor chip driver",
+       .id             = I2C_DRIVERID_LM75,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = lm75_attach_adapter,
+       .detach_client  = lm75_detach_client,
+};
+
+/* -- SENSORS SYSCTL START -- */
+
+#define LM75_SYSCTL_TEMP 1200  /* Degrees Celcius * 10 */
+
+/* -- SENSORS SYSCTL END -- */
+
+/* These files are created for each detected LM75. This is just a template;
+   though at first sight, you might think we could use a statically
+   allocated list, we need some way to get back to the parent - which
+   is done through one of the 'extra' fields which are initialized
+   when a new copy is allocated. */
+static ctl_table lm75_dir_table_template[] = {
+       {LM75_SYSCTL_TEMP, "temp", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &lm75_temp},
+       {0}
+};
+
+static int lm75_id = 0;
+
+static int lm75_attach_adapter(struct i2c_adapter *adapter)
+{
+       return i2c_detect(adapter, &addr_data, lm75_detect);
+}
+
+/* This function is called by i2c_detect */
+int lm75_detect(struct i2c_adapter *adapter, int address,
+               unsigned short flags, int kind)
+{
+       int i;
+       struct i2c_client *new_client;
+       struct lm75_data *data;
+       int err = 0;
+       const char *type_name, *client_name;
+
+       /* Make sure we aren't probing the ISA bus!! This is just a safety check
+          at this moment; i2c_detect really won't call us. */
+#ifdef DEBUG
+       if (i2c_is_isa_adapter(adapter)) {
+               printk
+                   ("lm75.o: lm75_detect called for an ISA bus adapter?!?\n");
+               return 0;
+       }
+#endif
+
+       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
+                                    I2C_FUNC_SMBUS_WORD_DATA))
+                   goto error0;
+
+       /* OK. For now, we presume we have a valid client. We now create the
+          client structure, even though we cannot fill it completely yet.
+          But it allows us to access lm75_{read,write}_value. */
+       if (!(data = kmalloc(sizeof(struct lm75_data), GFP_KERNEL))) {
+               err = -ENOMEM;
+               goto error0;
+       }
+
+       new_client = &data->client;
+       new_client->addr = address;
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &lm75_driver;
+       new_client->flags = 0;
+
+       /* Now, we do the remaining detection. There is no identification-
+          dedicated register so we have to rely on several tricks:
+          unused bits, registers cycling over 8-address boundaries,
+          addresses 0x04-0x07 returning the last read value.
+          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)
+                       goto error1;
+               os = i2c_smbus_read_word_data(new_client, 3);
+               if (i2c_smbus_read_word_data(new_client, 4) != os
+                || i2c_smbus_read_word_data(new_client, 5) != os
+                || i2c_smbus_read_word_data(new_client, 6) != os
+                || i2c_smbus_read_word_data(new_client, 7) != os)
+                       goto error1;
+
+               /* Unused bits */
+               if (conf & 0xe0)
+                       goto error1;
+
+               /* Addresses cycling */
+               for (i = 8; i < 0xff; i += 8)
+                       if (i2c_smbus_read_byte_data(new_client, i + 1) != conf
+                        || i2c_smbus_read_word_data(new_client, i + 2) != hyst
+                        || i2c_smbus_read_word_data(new_client, i + 3) != os)
+                               goto error1;
+       }
+
+       /* Determine the chip type - only one kind supported! */
+       if (kind <= 0)
+               kind = lm75;
+
+       if (kind == lm75) {
+               type_name = "lm75";
+               client_name = "LM75 chip";
+       } else {
+               pr_debug("lm75.o: Internal error: unknown kind (%d)?!?", kind);
+               goto error1;
+       }
+
+       /* Fill in the remaining client fields and put it into the global list */
+       strcpy(new_client->name, client_name);
+
+       new_client->id = lm75_id++;
+       data->valid = 0;
+       init_MUTEX(&data->update_lock);
+
+       /* Tell the I2C layer a new client has arrived */
+       if ((err = i2c_attach_client(new_client)))
+               goto error3;
+
+       /* Register a new directory entry with module sensors */
+       if ((i = i2c_register_entry(new_client, type_name,
+                                       lm75_dir_table_template)) < 0) {
+               err = i;
+               goto error4;
+       }
+       data->sysctl_id = i;
+
+       lm75_init_client(new_client);
+       return 0;
+
+/* OK, this is not exactly good programming practice, usually. But it is
+   very code-efficient in this case. */
+
+      error4:
+       i2c_detach_client(new_client);
+      error3:
+      error1:
+       kfree(data);
+      error0:
+       return err;
+}
+
+static int lm75_detach_client(struct i2c_client *client)
+{
+       struct lm75_data *data = client->data;
+
+       i2c_deregister_entry(data->sysctl_id);
+       i2c_detach_client(client);
+       kfree(client->data);
+       return 0;
+}
+
+/* All registers are word-sized, except for the configuration register.
+   LM75 uses a high-byte first convention, which is exactly opposite to
+   the usual practice. */
+static int lm75_read_value(struct i2c_client *client, u8 reg)
+{
+       if (reg == LM75_REG_CONF)
+               return i2c_smbus_read_byte_data(client, reg);
+       else
+               return swab16(i2c_smbus_read_word_data(client, reg));
+}
+
+/* All registers are word-sized, except for the configuration register.
+   LM75 uses a high-byte first convention, which is exactly opposite to
+   the usual practice. */
+static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value)
+{
+       if (reg == LM75_REG_CONF)
+               return i2c_smbus_write_byte_data(client, reg, value);
+       else
+               return i2c_smbus_write_word_data(client, reg, swab16(value));
+}
+
+static void lm75_init_client(struct i2c_client *client)
+{
+       /* Initialize the LM75 chip */
+       lm75_write_value(client, LM75_REG_CONF, 0);
+}
+
+static void lm75_update_client(struct i2c_client *client)
+{
+       struct lm75_data *data = client->data;
+
+       down(&data->update_lock);
+
+       if ((jiffies - data->last_updated > HZ + HZ / 2) ||
+           (jiffies < data->last_updated) || !data->valid) {
+               pr_debug("Starting lm75 update\n");
+
+               data->temp = lm75_read_value(client, LM75_REG_TEMP);
+               data->temp_os = lm75_read_value(client, LM75_REG_TEMP_OS);
+               data->temp_hyst =
+                   lm75_read_value(client, LM75_REG_TEMP_HYST);
+               data->last_updated = jiffies;
+               data->valid = 1;
+       }
+
+       up(&data->update_lock);
+}
+
+
+void lm75_temp(struct i2c_client *client, int operation, int ctl_name,
+              int *nrels_mag, long *results)
+{
+       struct lm75_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               lm75_update_client(client);
+               results[0] = LM75_TEMP_FROM_REG(data->temp_os);
+               results[1] = LM75_TEMP_FROM_REG(data->temp_hyst);
+               results[2] = LM75_TEMP_FROM_REG(data->temp);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->temp_os = LM75_TEMP_TO_REG(results[0]);
+                       lm75_write_value(client, LM75_REG_TEMP_OS,
+                                        data->temp_os);
+               }
+               if (*nrels_mag >= 2) {
+                       data->temp_hyst = LM75_TEMP_TO_REG(results[1]);
+                       lm75_write_value(client, LM75_REG_TEMP_HYST,
+                                        data->temp_hyst);
+               }
+       }
+}
+
+static int __init sm_lm75_init(void)
+{
+       printk(KERN_INFO "lm75.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       return i2c_add_driver(&lm75_driver);
+}
+
+static void __exit sm_lm75_exit(void)
+{
+       i2c_del_driver(&lm75_driver);
+}
+
+MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
+MODULE_DESCRIPTION("LM75 driver");
+MODULE_LICENSE("GPL");
+
+module_init(sm_lm75_init);
+module_exit(sm_lm75_exit);
--- linux-old/drivers/sensors/lm75.h    Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/lm75.h        Mon Dec 13 20:18:47 2004
@@ -0,0 +1,49 @@
+/*
+    lm75.h - Part of lm_sensors, Linux kernel modules for hardware
+             monitoring
+    Copyright (c) 2003 Mark M. Hoffman <mhoffman@lightlink.com>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+    This file contains common code for encoding/decoding LM75 type
+    temperature readings, which are emulated by many of the chips
+    we support.  As the user is unlikely to load more than one driver
+    which contains this code, we don't worry about the wasted space.
+*/
+
+#include <linux/i2c-proc.h>
+
+/* straight from the datasheet */
+#define LM75_TEMP_MIN (-550)
+#define LM75_TEMP_MAX 1250
+
+/* TEMP: 0.1C/bit (-55C to +125C)
+   REG: (0.5C/bit, two's complement) << 7 */
+static inline u16 LM75_TEMP_TO_REG(int temp)
+{
+       int ntemp = SENSORS_LIMIT(temp, LM75_TEMP_MIN, LM75_TEMP_MAX);
+       ntemp += (ntemp<0 ? -2 : 2);
+       return (u16)((ntemp / 5) << 7);
+}
+
+static inline int LM75_TEMP_FROM_REG(u16 reg)
+{
+       /* use integer division instead of equivalent right shift to
+          guarantee arithmetic shift and preserve the sign */
+       return ((s16)reg / 128) * 5;
+}
+
--- linux-old/drivers/sensors/lm78.c    Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/lm78.c        Mon Dec 13 20:18:47 2004
@@ -0,0 +1,729 @@
+/*
+    lm78.c - Part of lm_sensors, Linux kernel modules for hardware
+             monitoring
+    Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl> 
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/ioport.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#include <asm/io.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+MODULE_LICENSE("GPL");
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = { SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { 0x20, 0x2f, SENSORS_I2C_END };
+static unsigned int normal_isa[] = { 0x0290, SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+/* Insmod parameters */
+SENSORS_INSMOD_3(lm78, lm78j, lm79);
+
+/* Many LM78 constants specified below */
+
+/* Length of ISA address segment */
+#define LM78_EXTENT 8
+
+/* Where are the ISA address/data registers relative to the base address */
+#define LM78_ADDR_REG_OFFSET 5
+#define LM78_DATA_REG_OFFSET 6
+
+/* The LM78 registers */
+#define LM78_REG_IN_MAX(nr) (0x2b + (nr) * 2)
+#define LM78_REG_IN_MIN(nr) (0x2c + (nr) * 2)
+#define LM78_REG_IN(nr) (0x20 + (nr))
+
+#define LM78_REG_FAN_MIN(nr) (0x3a + (nr))
+#define LM78_REG_FAN(nr) (0x27 + (nr))
+
+#define LM78_REG_TEMP 0x27
+#define LM78_REG_TEMP_OVER 0x39
+#define LM78_REG_TEMP_HYST 0x3a
+
+#define LM78_REG_ALARM1 0x41
+#define LM78_REG_ALARM2 0x42
+
+#define LM78_REG_VID_FANDIV 0x47
+
+#define LM78_REG_CONFIG 0x40
+#define LM78_REG_CHIPID 0x49
+#define LM78_REG_I2C_ADDR 0x48
+
+
+/* Conversions. Limit checking is only done on the TO_REG 
+   variants. Note that you should be a bit careful with which arguments
+   these macros are called: arguments may be evaluated more than once.
+   Fixing this is just not worth it. */
+#define IN_TO_REG(val)  (SENSORS_LIMIT((((val) * 10 + 8)/16),0,255))
+#define IN_FROM_REG(val) (((val) *  16 + 5) / 10)
+
+static inline u8 FAN_TO_REG(long rpm, int div)
+{
+       if (rpm == 0)
+               return 255;
+       rpm = SENSORS_LIMIT(rpm, 1, 1000000);
+       return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1,
+                            254);
+}
+
+#define FAN_FROM_REG(val,div) ((val)==0?-1:(val)==255?0:1350000/((val)*(div)))
+
+#define TEMP_TO_REG(val) (SENSORS_LIMIT(((val)<0?(((val)-5)/10):\
+                                                 ((val)+5)/10),0,255))
+#define TEMP_FROM_REG(val) (((val)>0x80?(val)-0x100:(val))*10)
+
+#define VID_FROM_REG(val) ((val)==0x1f?0:(val)>=0x10?510-(val)*10:\
+                           205-(val)*5)
+#define ALARMS_FROM_REG(val) (val)
+
+#define DIV_TO_REG(val) ((val)==8?3:(val)==4?2:(val)==1?0:1)
+#define DIV_FROM_REG(val) (1 << (val))
+
+/* There are some complications in a module like this. First off, LM78 chips
+   may be both present on the SMBus and the ISA bus, and we have to handle
+   those cases separately at some places. Second, there might be several
+   LM78 chips available (well, actually, that is probably never done; but
+   it is a clean illustration of how to handle a case like that). Finally,
+   a specific chip may be attached to *both* ISA and SMBus, and we would
+   not like to detect it double. Fortunately, in the case of the LM78 at
+   least, a register tells us what SMBus address we are on, so that helps
+   a bit - except if there could be more than one SMBus. Groan. No solution
+   for this yet. */
+
+/* This module may seem overly long and complicated. In fact, it is not so
+   bad. Quite a lot of bookkeeping is done. A real driver can often cut
+   some corners. */
+
+/* For each registered LM78, we need to keep some data in memory. That
+   data is pointed to by lm78_list[NR]->data. The structure itself is
+   dynamically allocated, at the same time when a new lm78 client is
+   allocated. */
+struct lm78_data {
+       struct i2c_client client;
+       struct semaphore lock;
+       int sysctl_id;
+       enum chips type;
+
+       struct semaphore update_lock;
+       char valid;             /* !=0 if following fields are valid */
+       unsigned long last_updated;     /* In jiffies */
+
+       u8 in[7];               /* Register value */
+       u8 in_max[7];           /* Register value */
+       u8 in_min[7];           /* Register value */
+       u8 fan[3];              /* Register value */
+       u8 fan_min[3];          /* Register value */
+       u8 temp;                /* Register value */
+       u8 temp_over;           /* Register value */
+       u8 temp_hyst;           /* Register value */
+       u8 fan_div[3];          /* Register encoding, shifted right */
+       u8 vid;                 /* Register encoding, combined */
+       u16 alarms;             /* Register encoding, combined */
+};
+
+
+static int lm78_attach_adapter(struct i2c_adapter *adapter);
+static int lm78_detect(struct i2c_adapter *adapter, int address,
+                      unsigned short flags, int kind);
+static int lm78_detach_client(struct i2c_client *client);
+
+static int lm78_read_value(struct i2c_client *client, u8 register);
+static int lm78_write_value(struct i2c_client *client, u8 register,
+                           u8 value);
+static void lm78_update_client(struct i2c_client *client);
+static void lm78_init_client(struct i2c_client *client);
+
+
+static void lm78_in(struct i2c_client *client, int operation, int ctl_name,
+                   int *nrels_mag, long *results);
+static void lm78_fan(struct i2c_client *client, int operation,
+                    int ctl_name, int *nrels_mag, long *results);
+static void lm78_temp(struct i2c_client *client, int operation,
+                     int ctl_name, int *nrels_mag, long *results);
+static void lm78_vid(struct i2c_client *client, int operation,
+                    int ctl_name, int *nrels_mag, long *results);
+static void lm78_alarms(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void lm78_fan_div(struct i2c_client *client, int operation,
+                        int ctl_name, int *nrels_mag, long *results);
+
+static struct i2c_driver lm78_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "LM78(-J) and LM79 sensor driver",
+       .id             = I2C_DRIVERID_LM78,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = lm78_attach_adapter,
+       .detach_client  = lm78_detach_client,
+};
+
+static int lm78_id = 0;
+
+/* The /proc/sys entries */
+
+/* -- SENSORS SYSCTL START -- */
+#define LM78_SYSCTL_IN0 1000   /* Volts * 100 */
+#define LM78_SYSCTL_IN1 1001
+#define LM78_SYSCTL_IN2 1002
+#define LM78_SYSCTL_IN3 1003
+#define LM78_SYSCTL_IN4 1004
+#define LM78_SYSCTL_IN5 1005
+#define LM78_SYSCTL_IN6 1006
+#define LM78_SYSCTL_FAN1 1101  /* Rotations/min */
+#define LM78_SYSCTL_FAN2 1102
+#define LM78_SYSCTL_FAN3 1103
+#define LM78_SYSCTL_TEMP 1200  /* Degrees Celcius * 10 */
+#define LM78_SYSCTL_VID 1300   /* Volts * 100 */
+#define LM78_SYSCTL_FAN_DIV 2000       /* 1, 2, 4 or 8 */
+#define LM78_SYSCTL_ALARMS 2001        /* bitvector */
+
+#define LM78_ALARM_IN0 0x0001
+#define LM78_ALARM_IN1 0x0002
+#define LM78_ALARM_IN2 0x0004
+#define LM78_ALARM_IN3 0x0008
+#define LM78_ALARM_IN4 0x0100
+#define LM78_ALARM_IN5 0x0200
+#define LM78_ALARM_IN6 0x0400
+#define LM78_ALARM_FAN1 0x0040
+#define LM78_ALARM_FAN2 0x0080
+#define LM78_ALARM_FAN3 0x0800
+#define LM78_ALARM_TEMP 0x0010
+#define LM78_ALARM_BTI 0x0020
+#define LM78_ALARM_CHAS 0x1000
+#define LM78_ALARM_FIFO 0x2000
+#define LM78_ALARM_SMI_IN 0x4000
+
+/* -- SENSORS SYSCTL END -- */
+
+/* These files are created for each detected LM78. This is just a template;
+   though at first sight, you might think we could use a statically
+   allocated list, we need some way to get back to the parent - which
+   is done through one of the 'extra' fields which are initialized 
+   when a new copy is allocated. */
+static ctl_table lm78_dir_table_template[] = {
+       {LM78_SYSCTL_IN0, "in0", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &lm78_in},
+       {LM78_SYSCTL_IN1, "in1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &lm78_in},
+       {LM78_SYSCTL_IN2, "in2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &lm78_in},
+       {LM78_SYSCTL_IN3, "in3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &lm78_in},
+       {LM78_SYSCTL_IN4, "in4", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &lm78_in},
+       {LM78_SYSCTL_IN5, "in5", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &lm78_in},
+       {LM78_SYSCTL_IN6, "in6", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &lm78_in},
+       {LM78_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &lm78_fan},
+       {LM78_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &lm78_fan},
+       {LM78_SYSCTL_FAN3, "fan3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &lm78_fan},
+       {LM78_SYSCTL_TEMP, "temp", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &lm78_temp},
+       {LM78_SYSCTL_VID, "vid", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &lm78_vid},
+       {LM78_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &lm78_fan_div},
+       {LM78_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &lm78_alarms},
+       {0}
+};
+
+
+/* This function is called when:
+     * lm78_driver is inserted (when this module is loaded), for each
+       available adapter
+     * when a new adapter is inserted (and lm78_driver is still present) */
+static int lm78_attach_adapter(struct i2c_adapter *adapter)
+{
+       return i2c_detect(adapter, &addr_data, lm78_detect);
+}
+
+/* This function is called by i2c_detect */
+int lm78_detect(struct i2c_adapter *adapter, int address,
+               unsigned short flags, int kind)
+{
+       int i;
+       struct i2c_client *new_client;
+       struct lm78_data *data;
+       int err = 0;
+       const char *type_name = "";
+       const char *client_name = "";
+       int is_isa = i2c_is_isa_adapter(adapter);
+
+       if (!is_isa
+           && !i2c_check_functionality(adapter,
+                                       I2C_FUNC_SMBUS_BYTE_DATA)) goto
+                   ERROR0;
+
+       if (is_isa) {
+               if (check_region(address, LM78_EXTENT))
+                       goto ERROR0;
+       }
+
+       /* Probe whether there is anything available on this address. Already
+          done for SMBus clients */
+       if (kind < 0) {
+               if (is_isa) {
+
+#define REALLY_SLOW_IO
+                       /* We need the timeouts for at least some LM78-like chips. But only
+                          if we read 'undefined' registers. */
+                       i = inb_p(address + 1);
+                       if (inb_p(address + 2) != i)
+                               goto ERROR0;
+                       if (inb_p(address + 3) != i)
+                               goto ERROR0;
+                       if (inb_p(address + 7) != i)
+                               goto ERROR0;
+#undef REALLY_SLOW_IO
+
+                       /* Let's just hope nothing breaks here */
+                       i = inb_p(address + 5) & 0x7f;
+                       outb_p(~i & 0x7f, address + 5);
+                       if ((inb_p(address + 5) & 0x7f) != (~i & 0x7f)) {
+                               outb_p(i, address + 5);
+                               return 0;
+                       }
+               }
+       }
+
+       /* OK. For now, we presume we have a valid client. We now create the
+          client structure, even though we cannot fill it completely yet.
+          But it allows us to access lm78_{read,write}_value. */
+
+       if (!(data = kmalloc(sizeof(struct lm78_data), GFP_KERNEL))) {
+               err = -ENOMEM;
+               goto ERROR0;
+       }
+
+       new_client = &data->client;
+       if (is_isa)
+               init_MUTEX(&data->lock);
+       new_client->addr = address;
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &lm78_driver;
+       new_client->flags = 0;
+
+       /* Now, we do the remaining detection. */
+
+       if (kind < 0) {
+               if (lm78_read_value(new_client, LM78_REG_CONFIG) & 0x80)
+                       goto ERROR1;
+               if (!is_isa
+                   && (lm78_read_value(new_client, LM78_REG_I2C_ADDR) !=
+                       address)) goto ERROR1;
+       }
+
+       /* Determine the chip type. */
+       if (kind <= 0) {
+               i = lm78_read_value(new_client, LM78_REG_CHIPID);
+               if (i == 0x00 || i == 0x20)
+                       kind = lm78;
+               else if (i == 0x40)
+                       kind = lm78j;
+               else if ((i & 0xfe) == 0xc0)
+                       kind = lm79;
+               else {
+                       if (kind == 0)
+                               printk
+                                   ("lm78.o: Ignoring 'force' parameter for unknown chip at "
+                                    "adapter %d, address 0x%02x\n",
+                                    i2c_adapter_id(adapter), address);
+                       goto ERROR1;
+               }
+       }
+
+       if (kind == lm78) {
+               type_name = "lm78";
+               client_name = "LM78 chip";
+       } else if (kind == lm78j) {
+               type_name = "lm78-j";
+               client_name = "LM78-J chip";
+       } else if (kind == lm79) {
+               type_name = "lm79";
+               client_name = "LM79 chip";
+       } else {
+#ifdef DEBUG
+               printk("lm78.o: Internal error: unknown kind (%d)?!?",
+                      kind);
+#endif
+               goto ERROR1;
+       }
+
+       /* Reserve the ISA region */
+       if (is_isa)
+               request_region(address, LM78_EXTENT, type_name);
+
+       /* Fill in the remaining client fields and put it into the global list */
+       strcpy(new_client->name, client_name);
+       data->type = kind;
+
+       new_client->id = lm78_id++;
+       data->valid = 0;
+       init_MUTEX(&data->update_lock);
+
+       /* Tell the I2C layer a new client has arrived */
+       if ((err = i2c_attach_client(new_client)))
+               goto ERROR3;
+
+       /* Register a new directory entry with module sensors */
+       if ((i = i2c_register_entry(new_client,
+                                       type_name,
+                                       lm78_dir_table_template)) < 0) {
+               err = i;
+               goto ERROR4;
+       }
+       data->sysctl_id = i;
+
+       /* Initialize the LM78 chip */
+       lm78_init_client(new_client);
+       return 0;
+
+/* OK, this is not exactly good programming practice, usually. But it is
+   very code-efficient in this case. */
+
+      ERROR4:
+       i2c_detach_client(new_client);
+      ERROR3:
+       if (is_isa)
+               release_region(address, LM78_EXTENT);
+      ERROR1:
+       kfree(data);
+      ERROR0:
+       return err;
+}
+
+static int lm78_detach_client(struct i2c_client *client)
+{
+       int err;
+
+       i2c_deregister_entry(((struct lm78_data *) (client->data))->
+                                sysctl_id);
+
+       if ((err = i2c_detach_client(client))) {
+               printk
+                   ("lm78.o: Client deregistration failed, client not detached.\n");
+               return err;
+       }
+
+       if(i2c_is_isa_client(client))
+               release_region(client->addr, LM78_EXTENT);
+       kfree(client->data);
+
+       return 0;
+}
+
+/* The SMBus locks itself, but ISA access must be locked explicitely! 
+   We don't want to lock the whole ISA bus, so we lock each client
+   separately.
+   We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
+   would slow down the LM78 access and should not be necessary. 
+   There are some ugly typecasts here, but the good new is - they should
+   nowhere else be necessary! */
+static int lm78_read_value(struct i2c_client *client, u8 reg)
+{
+       int res;
+       if (i2c_is_isa_client(client)) {
+               down(&(((struct lm78_data *) (client->data))->lock));
+               outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET);
+               res = inb_p(client->addr + LM78_DATA_REG_OFFSET);
+               up(&(((struct lm78_data *) (client->data))->lock));
+               return res;
+       } else
+               return i2c_smbus_read_byte_data(client, reg);
+}
+
+/* The SMBus locks itself, but ISA access muse be locked explicitely! 
+   We don't want to lock the whole ISA bus, so we lock each client
+   separately.
+   We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
+   would slow down the LM78 access and should not be necessary. 
+   There are some ugly typecasts here, but the good new is - they should
+   nowhere else be necessary! */
+static int lm78_write_value(struct i2c_client *client, u8 reg, u8 value)
+{
+       if (i2c_is_isa_client(client)) {
+               down(&(((struct lm78_data *) (client->data))->lock));
+               outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET);
+               outb_p(value, client->addr + LM78_DATA_REG_OFFSET);
+               up(&(((struct lm78_data *) (client->data))->lock));
+               return 0;
+       } else
+               return i2c_smbus_write_byte_data(client, reg, value);
+}
+
+/* Called when we have found a new LM78. */
+static void lm78_init_client(struct i2c_client *client)
+{
+       u8 config = lm78_read_value(client, LM78_REG_CONFIG);
+
+       /* Start monitoring */
+       if (!(config & 0x01))
+               lm78_write_value(client, LM78_REG_CONFIG,
+                                (config & 0xf7) | 0x01);
+}
+
+static void lm78_update_client(struct i2c_client *client)
+{
+       struct lm78_data *data = client->data;
+       int i;
+
+       down(&data->update_lock);
+
+       if ((jiffies - data->last_updated > HZ + HZ / 2) ||
+           (jiffies < data->last_updated) || !data->valid) {
+
+#ifdef DEBUG
+               printk("Starting lm78 update\n");
+#endif
+               for (i = 0; i <= 6; i++) {
+                       data->in[i] =
+                           lm78_read_value(client, LM78_REG_IN(i));
+                       data->in_min[i] =
+                           lm78_read_value(client, LM78_REG_IN_MIN(i));
+                       data->in_max[i] =
+                           lm78_read_value(client, LM78_REG_IN_MAX(i));
+               }
+               for (i = 1; i <= 3; i++) {
+                       data->fan[i - 1] =
+                           lm78_read_value(client, LM78_REG_FAN(i));
+                       data->fan_min[i - 1] =
+                           lm78_read_value(client, LM78_REG_FAN_MIN(i));
+               }
+               data->temp = lm78_read_value(client, LM78_REG_TEMP);
+               data->temp_over =
+                   lm78_read_value(client, LM78_REG_TEMP_OVER);
+               data->temp_hyst =
+                   lm78_read_value(client, LM78_REG_TEMP_HYST);
+               i = lm78_read_value(client, LM78_REG_VID_FANDIV);
+               data->vid = i & 0x0f;
+               if (data->type == lm79)
+                       data->vid |=
+                           (lm78_read_value(client, LM78_REG_CHIPID) &
+                            0x01) << 4;
+               else
+                       data->vid |= 0x10;
+               data->fan_div[0] = (i >> 4) & 0x03;
+               data->fan_div[1] = i >> 6;
+               data->alarms = lm78_read_value(client, LM78_REG_ALARM1) +
+                   (lm78_read_value(client, LM78_REG_ALARM2) << 8);
+               data->last_updated = jiffies;
+               data->valid = 1;
+
+               data->fan_div[2] = 1;
+       }
+
+       up(&data->update_lock);
+}
+
+
+/* The next few functions are the call-back functions of the /proc/sys and
+   sysctl files. Which function is used is defined in the ctl_table in
+   the extra1 field.
+   Each function must return the magnitude (power of 10 to divide the date
+   with) if it is called with operation==SENSORS_PROC_REAL_INFO. It must
+   put a maximum of *nrels elements in results reflecting the data of this
+   file, and set *nrels to the number it actually put in it, if operation==
+   SENSORS_PROC_REAL_READ. Finally, it must get upto *nrels elements from
+   results and write them to the chip, if operations==SENSORS_PROC_REAL_WRITE.
+   Note that on SENSORS_PROC_REAL_READ, I do not check whether results is
+   large enough (by checking the incoming value of *nrels). This is not very
+   good practice, but as long as you put less than about 5 values in results,
+   you can assume it is large enough. */
+void lm78_in(struct i2c_client *client, int operation, int ctl_name,
+            int *nrels_mag, long *results)
+{
+       struct lm78_data *data = client->data;
+       int nr = ctl_name - LM78_SYSCTL_IN0;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 2;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               lm78_update_client(client);
+               results[0] = IN_FROM_REG(data->in_min[nr]);
+               results[1] = IN_FROM_REG(data->in_max[nr]);
+               results[2] = IN_FROM_REG(data->in[nr]);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->in_min[nr] = IN_TO_REG(results[0]);
+                       lm78_write_value(client, LM78_REG_IN_MIN(nr),
+                                        data->in_min[nr]);
+               }
+               if (*nrels_mag >= 2) {
+                       data->in_max[nr] = IN_TO_REG(results[1]);
+                       lm78_write_value(client, LM78_REG_IN_MAX(nr),
+                                        data->in_max[nr]);
+               }
+       }
+}
+
+void lm78_fan(struct i2c_client *client, int operation, int ctl_name,
+             int *nrels_mag, long *results)
+{
+       struct lm78_data *data = client->data;
+       int nr = ctl_name - LM78_SYSCTL_FAN1 + 1;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               lm78_update_client(client);
+               results[0] = FAN_FROM_REG(data->fan_min[nr - 1],
+                                         DIV_FROM_REG(data->
+                                                      fan_div[nr - 1]));
+               results[1] =
+                   FAN_FROM_REG(data->fan[nr - 1],
+                                DIV_FROM_REG(data->fan_div[nr - 1]));
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->fan_min[nr - 1] = FAN_TO_REG(results[0],
+                                                          DIV_FROM_REG
+                                                          (data->
+                                                           fan_div[nr -
+                                                                   1]));
+                       lm78_write_value(client, LM78_REG_FAN_MIN(nr),
+                                        data->fan_min[nr - 1]);
+               }
+       }
+}
+
+
+void lm78_temp(struct i2c_client *client, int operation, int ctl_name,
+              int *nrels_mag, long *results)
+{
+       struct lm78_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               lm78_update_client(client);
+               results[0] = TEMP_FROM_REG(data->temp_over);
+               results[1] = TEMP_FROM_REG(data->temp_hyst);
+               results[2] = TEMP_FROM_REG(data->temp);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->temp_over = TEMP_TO_REG(results[0]);
+                       lm78_write_value(client, LM78_REG_TEMP_OVER,
+                                        data->temp_over);
+               }
+               if (*nrels_mag >= 2) {
+                       data->temp_hyst = TEMP_TO_REG(results[1]);
+                       lm78_write_value(client, LM78_REG_TEMP_HYST,
+                                        data->temp_hyst);
+               }
+       }
+}
+
+void lm78_vid(struct i2c_client *client, int operation, int ctl_name,
+             int *nrels_mag, long *results)
+{
+       struct lm78_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 2;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               lm78_update_client(client);
+               results[0] = VID_FROM_REG(data->vid);
+               *nrels_mag = 1;
+       }
+}
+
+void lm78_alarms(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct lm78_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               lm78_update_client(client);
+               results[0] = ALARMS_FROM_REG(data->alarms);
+               *nrels_mag = 1;
+       }
+}
+
+/* Note: we save and restore the fan minimum here, because its value is
+   determined in part by the fan divisor.  This follows the principle of
+   least surprise: the user doesn't expect the fan minimum to change just
+   because the divisor changed. */
+void lm78_fan_div(struct i2c_client *client, int operation, int ctl_name,
+                 int *nrels_mag, long *results)
+{
+       struct lm78_data *data = client->data;
+       int old, min;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               lm78_update_client(client);
+               results[0] = DIV_FROM_REG(data->fan_div[0]);
+               results[1] = DIV_FROM_REG(data->fan_div[1]);
+               results[2] = 2;
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               old = lm78_read_value(client, LM78_REG_VID_FANDIV);
+               if (*nrels_mag >= 2) {
+                       min = FAN_FROM_REG(data->fan_min[1], 
+                                       DIV_FROM_REG(data->fan_div[1]));
+                       data->fan_div[1] = DIV_TO_REG(results[1]);
+                       old = (old & 0x3f) | (data->fan_div[1] << 6);
+                       data->fan_min[1] = FAN_TO_REG(min,
+                                       DIV_FROM_REG(data->fan_div[1]));
+                       lm78_write_value(client, LM78_REG_FAN_MIN(2),
+                                       data->fan_min[1]);
+               }
+               if (*nrels_mag >= 1) {
+                       min = FAN_FROM_REG(data->fan_min[0],
+                                       DIV_FROM_REG(data->fan_div[0]));
+                       data->fan_div[0] = DIV_TO_REG(results[0]);
+                       old = (old & 0xcf) | (data->fan_div[0] << 4);
+                       data->fan_min[0] = FAN_TO_REG(min,
+                                       DIV_FROM_REG(data->fan_div[0]));
+                       lm78_write_value(client, LM78_REG_FAN_MIN(1),
+                                       data->fan_min[0]);
+                       lm78_write_value(client, LM78_REG_VID_FANDIV, old);
+               }
+       }
+}
+
+static int __init sm_lm78_init(void)
+{
+       printk("lm78.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       return i2c_add_driver(&lm78_driver);
+}
+
+static void __exit sm_lm78_exit(void)
+{
+       i2c_del_driver(&lm78_driver);
+}
+
+
+
+MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
+MODULE_DESCRIPTION("LM78, LM78-J and LM79 driver");
+
+module_init(sm_lm78_init);
+module_exit(sm_lm78_exit);
--- linux-old/drivers/sensors/lm80.c    Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/lm80.c        Mon Dec 13 20:18:48 2004
@@ -0,0 +1,606 @@
+/*
+    lm80.c - Part of lm_sensors, Linux kernel modules for hardware
+             monitoring
+    Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl>
+    and Philip Edelbrock <phil@netroedge.com>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+MODULE_LICENSE("GPL");
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = { SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { 0x20, 0x2f, SENSORS_I2C_END };
+static unsigned int normal_isa[] = { SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+/* Insmod parameters */
+SENSORS_INSMOD_1(lm80);
+
+/* Many LM80 constants specified below */
+
+/* The LM80 registers */
+#define LM80_REG_IN_MAX(nr) (0x2a + (nr) * 2)
+#define LM80_REG_IN_MIN(nr) (0x2b + (nr) * 2)
+#define LM80_REG_IN(nr) (0x20 + (nr))
+
+#define LM80_REG_FAN1_MIN 0x3c
+#define LM80_REG_FAN2_MIN 0x3d
+#define LM80_REG_FAN1 0x28
+#define LM80_REG_FAN2 0x29
+
+#define LM80_REG_TEMP 0x27
+#define LM80_REG_TEMP_HOT_MAX 0x38
+#define LM80_REG_TEMP_HOT_HYST 0x39
+#define LM80_REG_TEMP_OS_MAX 0x3a
+#define LM80_REG_TEMP_OS_HYST 0x3b
+
+#define LM80_REG_CONFIG 0x00
+#define LM80_REG_ALARM1 0x01
+#define LM80_REG_ALARM2 0x02
+#define LM80_REG_MASK1 0x03
+#define LM80_REG_MASK2 0x04
+#define LM80_REG_FANDIV 0x05
+#define LM80_REG_RES 0x06
+
+
+/* Conversions. Rounding and limit checking is only done on the TO_REG
+   variants. Note that you should be a bit careful with which arguments
+   these macros are called: arguments may be evaluated more than once.
+   Fixing this is just not worth it. */
+
+#define IN_TO_REG(val) (SENSORS_LIMIT((val),0,255))
+#define IN_FROM_REG(val) (val)
+
+static inline unsigned char FAN_TO_REG(unsigned rpm, unsigned div)
+{
+       if (rpm == 0)
+               return 255;
+       rpm = SENSORS_LIMIT(rpm, 1, 1000000);
+       return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1,
+                            254);
+}
+
+#define FAN_FROM_REG(val,div) ((val)==0?-1:\
+                               (val)==255?0:1350000/((div)*(val)))
+
+static inline long TEMP_FROM_REG(u16 temp)
+{
+       long res;
+
+       temp >>= 4;
+       if (temp < 0x0800)
+               res = 625 * (long) temp;
+       else
+               res = ((long) temp - 0x01000) * 625;
+
+       return res / 100;
+}
+
+#define TEMP_LIMIT_FROM_REG(val) (((val)>0x80?(val)-0x100:(val))*100)
+
+#define TEMP_LIMIT_TO_REG(val) SENSORS_LIMIT(((val)<0?(((val)-50)/100):\
+                                                      ((val)+50)/100), \
+                                             0,255)
+
+#define ALARMS_FROM_REG(val) (val)
+
+#define DIV_FROM_REG(val) (1 << (val))
+#define DIV_TO_REG(val) ((val)==8?3:(val)==4?2:(val)==1?0:1)
+
+struct lm80_data {
+       struct i2c_client client;
+       int sysctl_id;
+
+       struct semaphore update_lock;
+       char valid;             /* !=0 if following fields are valid */
+       unsigned long last_updated;     /* In jiffies */
+
+       u8 in[7];               /* Register value */
+       u8 in_max[7];           /* Register value */
+       u8 in_min[7];           /* Register value */
+       u8 fan[2];              /* Register value */
+       u8 fan_min[2];          /* Register value */
+       u8 fan_div[2];          /* Register encoding, shifted right */
+       u16 temp;               /* Register values, shifted right */
+       u8 temp_hot_max;        /* Register value */
+       u8 temp_hot_hyst;       /* Register value */
+       u8 temp_os_max;         /* Register value */
+       u8 temp_os_hyst;        /* Register value */
+       u16 alarms;             /* Register encoding, combined */
+};
+
+
+
+static int lm80_attach_adapter(struct i2c_adapter *adapter);
+static int lm80_detect(struct i2c_adapter *adapter, int address,
+                      unsigned short flags, int kind);
+static int lm80_detach_client(struct i2c_client *client);
+
+static int lm80_read_value(struct i2c_client *client, u8 reg);
+static int lm80_write_value(struct i2c_client *client, u8 reg, u8 value);
+static void lm80_update_client(struct i2c_client *client);
+static void lm80_init_client(struct i2c_client *client);
+
+
+static void lm80_in(struct i2c_client *client, int operation, int ctl_name,
+                   int *nrels_mag, long *results);
+static void lm80_fan(struct i2c_client *client, int operation,
+                    int ctl_name, int *nrels_mag, long *results);
+static void lm80_temp(struct i2c_client *client, int operation,
+                     int ctl_name, int *nrels_mag, long *results);
+static void lm80_alarms(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void lm80_fan_div(struct i2c_client *client, int operation,
+                        int ctl_name, int *nrels_mag, long *results);
+
+static int lm80_id = 0;
+
+static struct i2c_driver lm80_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "LM80 sensor driver",
+       .id             = I2C_DRIVERID_LM80,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = lm80_attach_adapter,
+       .detach_client  = lm80_detach_client,
+};
+
+/* The /proc/sys entries */
+
+/* -- SENSORS SYSCTL START -- */
+
+#define LM80_SYSCTL_IN0 1000   /* Volts * 100 */
+#define LM80_SYSCTL_IN1 1001
+#define LM80_SYSCTL_IN2 1002
+#define LM80_SYSCTL_IN3 1003
+#define LM80_SYSCTL_IN4 1004
+#define LM80_SYSCTL_IN5 1005
+#define LM80_SYSCTL_IN6 1006
+#define LM80_SYSCTL_FAN1 1101  /* Rotations/min */
+#define LM80_SYSCTL_FAN2 1102
+#define LM80_SYSCTL_TEMP 1250  /* Degrees Celcius * 100 */
+#define LM80_SYSCTL_FAN_DIV 2000       /* 1, 2, 4 or 8 */
+#define LM80_SYSCTL_ALARMS 2001        /* bitvector */
+
+#define LM80_ALARM_IN0 0x0001
+#define LM80_ALARM_IN1 0x0002
+#define LM80_ALARM_IN2 0x0004
+#define LM80_ALARM_IN3 0x0008
+#define LM80_ALARM_IN4 0x0010
+#define LM80_ALARM_IN5 0x0020
+#define LM80_ALARM_IN6 0x0040
+#define LM80_ALARM_FAN1 0x0400
+#define LM80_ALARM_FAN2 0x0800
+#define LM80_ALARM_TEMP_HOT 0x0100
+#define LM80_ALARM_TEMP_OS 0x2000
+#define LM80_ALARM_CHAS 0x1000
+#define LM80_ALARM_BTI 0x0200
+#define LM80_ALARM_INT_IN 0x0080
+
+/* -- SENSORS SYSCTL END -- */
+
+/* These files are created for each detected LM80. This is just a template;
+   though at first sight, you might think we could use a statically
+   allocated list, we need some way to get back to the parent - which
+   is done through one of the 'extra' fields which are initialized 
+   when a new copy is allocated. */
+static ctl_table lm80_dir_table_template[] = {
+       {LM80_SYSCTL_IN0, "in0", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &lm80_in},
+       {LM80_SYSCTL_IN1, "in1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &lm80_in},
+       {LM80_SYSCTL_IN2, "in2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &lm80_in},
+       {LM80_SYSCTL_IN3, "in3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &lm80_in},
+       {LM80_SYSCTL_IN4, "in4", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &lm80_in},
+       {LM80_SYSCTL_IN5, "in5", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &lm80_in},
+       {LM80_SYSCTL_IN6, "in6", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &lm80_in},
+       {LM80_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &lm80_fan},
+       {LM80_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &lm80_fan},
+       {LM80_SYSCTL_TEMP, "temp", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &lm80_temp},
+       {LM80_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &lm80_fan_div},
+       {LM80_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &lm80_alarms},
+       {0}
+};
+
+static int lm80_attach_adapter(struct i2c_adapter *adapter)
+{
+       return i2c_detect(adapter, &addr_data, lm80_detect);
+}
+
+int lm80_detect(struct i2c_adapter *adapter, int address,
+               unsigned short flags, int kind)
+{
+       int i, cur;
+       struct i2c_client *new_client;
+       struct lm80_data *data;
+       int err = 0;
+       const char *type_name, *client_name;
+
+       /* Make sure we aren't probing the ISA bus!! This is just a safety check
+          at this moment; i2c_detect really won't call us. */
+#ifdef DEBUG
+       if (i2c_is_isa_adapter(adapter)) {
+               printk
+                   ("lm80.o: lm80_detect called for an ISA bus adapter?!?\n");
+               return 0;
+       }
+#endif
+
+       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
+               goto ERROR0;
+
+       /* OK. For now, we presume we have a valid client. We now create the
+          client structure, even though we cannot fill it completely yet.
+          But it allows us to access lm80_{read,write}_value. */
+       if (!(data = kmalloc(sizeof(struct lm80_data), GFP_KERNEL))) {
+               err = -ENOMEM;
+               goto ERROR0;
+       }
+
+       new_client = &data->client;
+       new_client->addr = address;
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &lm80_driver;
+       new_client->flags = 0;
+
+       /* Now, we do the remaining detection. It is lousy. */
+       if (lm80_read_value(new_client, LM80_REG_ALARM2) & 0xc0)
+               goto ERROR1;
+       for (i = 0x2a; i <= 0x3d; i++) {
+               cur = i2c_smbus_read_byte_data(new_client, i);
+               if ((i2c_smbus_read_byte_data(new_client, i + 0x40) != cur)
+                   || (i2c_smbus_read_byte_data(new_client, i + 0x80) !=
+                       cur)
+                   || (i2c_smbus_read_byte_data(new_client, i + 0xc0) !=
+                       cur)) goto ERROR1;
+       }
+
+       /* Determine the chip type - only one kind supported! */
+       if (kind <= 0)
+               kind = lm80;
+
+       if (kind == lm80) {
+               type_name = "lm80";
+               client_name = "LM80 chip";
+       } else {
+#ifdef DEBUG
+               printk("lm80.o: Internal error: unknown kind (%d)?!?",
+                      kind);
+#endif
+               goto ERROR1;
+       }
+
+       /* Fill in the remaining client fields and put it into the global list */
+       strcpy(new_client->name, client_name);
+
+       new_client->id = lm80_id++;
+       data->valid = 0;
+       init_MUTEX(&data->update_lock);
+
+       /* Tell the I2C layer a new client has arrived */
+       if ((err = i2c_attach_client(new_client)))
+               goto ERROR3;
+
+       /* Register a new directory entry with module sensors */
+       if ((i = i2c_register_entry(new_client, type_name,
+                                       lm80_dir_table_template)) < 0) {
+               err = i;
+               goto ERROR4;
+       }
+       data->sysctl_id = i;
+
+       lm80_init_client(new_client);
+       return 0;
+
+/* OK, this is not exactly good programming practice, usually. But it is
+   very code-efficient in this case. */
+      ERROR4:
+       i2c_detach_client(new_client);
+      ERROR3:
+      ERROR1:
+       kfree(data);
+      ERROR0:
+       return err;
+}
+
+static int lm80_detach_client(struct i2c_client *client)
+{
+       int err;
+
+       i2c_deregister_entry(((struct lm80_data *) (client->data))->
+                                sysctl_id);
+
+       if ((err = i2c_detach_client(client))) {
+               printk
+                   ("lm80.o: Client deregistration failed, client not detached.\n");
+               return err;
+       }
+
+       kfree(client->data);
+
+       return 0;
+}
+
+static int lm80_read_value(struct i2c_client *client, u8 reg)
+{
+       return i2c_smbus_read_byte_data(client, reg);
+}
+
+static int lm80_write_value(struct i2c_client *client, u8 reg, u8 value)
+{
+       return i2c_smbus_write_byte_data(client, reg, value);
+}
+
+/* Called when we have found a new LM80. */
+static void lm80_init_client(struct i2c_client *client)
+{
+       /* Reset all except Watchdog values and last conversion values
+          This sets fan-divs to 2, among others. This makes most other
+          initializations unnecessary */
+       lm80_write_value(client, LM80_REG_CONFIG, 0x80);
+       /* Set 11-bit temperature resolution */
+       lm80_write_value(client, LM80_REG_RES, 0x08);
+
+       /* Start monitoring */
+       lm80_write_value(client, LM80_REG_CONFIG, 0x01);
+}
+
+static void lm80_update_client(struct i2c_client *client)
+{
+       struct lm80_data *data = client->data;
+       int i;
+
+       down(&data->update_lock);
+
+       if ((jiffies - data->last_updated > 2 * HZ) ||
+           (jiffies < data->last_updated) || !data->valid) {
+
+#ifdef DEBUG
+               printk("Starting lm80 update\n");
+#endif
+               for (i = 0; i <= 6; i++) {
+                       data->in[i] =
+                           lm80_read_value(client, LM80_REG_IN(i));
+                       data->in_min[i] =
+                           lm80_read_value(client, LM80_REG_IN_MIN(i));
+                       data->in_max[i] =
+                           lm80_read_value(client, LM80_REG_IN_MAX(i));
+               }
+               data->fan[0] = lm80_read_value(client, LM80_REG_FAN1);
+               data->fan_min[0] =
+                   lm80_read_value(client, LM80_REG_FAN1_MIN);
+               data->fan[1] = lm80_read_value(client, LM80_REG_FAN2);
+               data->fan_min[1] =
+                   lm80_read_value(client, LM80_REG_FAN2_MIN);
+
+               data->temp =
+                   (lm80_read_value(client, LM80_REG_TEMP) << 8) |
+                   (lm80_read_value(client, LM80_REG_RES) & 0xf0);
+               data->temp_os_max =
+                   lm80_read_value(client, LM80_REG_TEMP_OS_MAX);
+               data->temp_os_hyst =
+                   lm80_read_value(client, LM80_REG_TEMP_OS_HYST);
+               data->temp_hot_max =
+                   lm80_read_value(client, LM80_REG_TEMP_HOT_MAX);
+               data->temp_hot_hyst =
+                   lm80_read_value(client, LM80_REG_TEMP_HOT_HYST);
+
+               i = lm80_read_value(client, LM80_REG_FANDIV);
+               data->fan_div[0] = (i >> 2) & 0x03;
+               data->fan_div[1] = (i >> 4) & 0x03;
+               data->alarms = lm80_read_value(client, LM80_REG_ALARM1) +
+                   (lm80_read_value(client, LM80_REG_ALARM2) << 8);
+               data->last_updated = jiffies;
+               data->valid = 1;
+       }
+
+       up(&data->update_lock);
+}
+
+
+/* The next few functions are the call-back functions of the /proc/sys and
+   sysctl files. Which function is used is defined in the ctl_table in
+   the extra1 field.
+   Each function must return the magnitude (power of 10 to divide the date
+   with) if it is called with operation==SENSORS_PROC_REAL_INFO. It must
+   put a maximum of *nrels elements in results reflecting the data of this
+   file, and set *nrels to the number it actually put in it, if operation==
+   SENSORS_PROC_REAL_READ. Finally, it must get upto *nrels elements from
+   results and write them to the chip, if operations==SENSORS_PROC_REAL_WRITE.
+   Note that on SENSORS_PROC_REAL_READ, I do not check whether results is
+   large enough (by checking the incoming value of *nrels). This is not very
+   good practice, but as long as you put less than about 5 values in results,
+   you can assume it is large enough. */
+void lm80_in(struct i2c_client *client, int operation, int ctl_name,
+            int *nrels_mag, long *results)
+{
+       struct lm80_data *data = client->data;
+       int nr = ctl_name - LM80_SYSCTL_IN0;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 2;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               lm80_update_client(client);
+               results[0] = IN_FROM_REG(data->in_min[nr]);
+               results[1] = IN_FROM_REG(data->in_max[nr]);
+               results[2] = IN_FROM_REG(data->in[nr]);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->in_min[nr] = IN_TO_REG(results[0]);
+                       lm80_write_value(client, LM80_REG_IN_MIN(nr),
+                                        data->in_min[nr]);
+               }
+               if (*nrels_mag >= 2) {
+                       data->in_max[nr] = IN_TO_REG(results[1]);
+                       lm80_write_value(client, LM80_REG_IN_MAX(nr),
+                                        data->in_max[nr]);
+               }
+       }
+}
+
+void lm80_fan(struct i2c_client *client, int operation, int ctl_name,
+             int *nrels_mag, long *results)
+{
+       struct lm80_data *data = client->data;
+       int nr = ctl_name - LM80_SYSCTL_FAN1 + 1;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               lm80_update_client(client);
+               results[0] = FAN_FROM_REG(data->fan_min[nr - 1],
+                                         DIV_FROM_REG(data->
+                                                      fan_div[nr - 1]));
+               results[1] =
+                   FAN_FROM_REG(data->fan[nr - 1],
+                                DIV_FROM_REG(data->fan_div[nr - 1]));
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->fan_min[nr - 1] = FAN_TO_REG(results[0],
+                                                          DIV_FROM_REG
+                                                          (data->
+                                                           fan_div[nr -
+                                                                   1]));
+                       lm80_write_value(client,
+                                        nr ==
+                                        1 ? LM80_REG_FAN1_MIN :
+                                        LM80_REG_FAN2_MIN,
+                                        data->fan_min[nr - 1]);
+               }
+       }
+}
+
+
+void lm80_temp(struct i2c_client *client, int operation, int ctl_name,
+              int *nrels_mag, long *results)
+{
+       struct lm80_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 2;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               lm80_update_client(client);
+               results[0] = TEMP_LIMIT_FROM_REG(data->temp_hot_max);
+               results[1] = TEMP_LIMIT_FROM_REG(data->temp_hot_hyst);
+               results[2] = TEMP_LIMIT_FROM_REG(data->temp_os_max);
+               results[3] = TEMP_LIMIT_FROM_REG(data->temp_os_hyst);
+               results[4] = TEMP_FROM_REG(data->temp);
+               *nrels_mag = 5;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->temp_hot_max = TEMP_LIMIT_TO_REG(results[0]);
+                       lm80_write_value(client, LM80_REG_TEMP_HOT_MAX,
+                                        data->temp_hot_max);
+               }
+               if (*nrels_mag >= 2) {
+                       data->temp_hot_hyst =
+                           TEMP_LIMIT_TO_REG(results[1]);
+                       lm80_write_value(client, LM80_REG_TEMP_HOT_HYST,
+                                        data->temp_hot_hyst);
+               }
+               if (*nrels_mag >= 3) {
+                       data->temp_os_max = TEMP_LIMIT_TO_REG(results[2]);
+                       lm80_write_value(client, LM80_REG_TEMP_OS_MAX,
+                                        data->temp_os_max);
+               }
+               if (*nrels_mag >= 4) {
+                       data->temp_os_hyst = TEMP_LIMIT_TO_REG(results[3]);
+                       lm80_write_value(client, LM80_REG_TEMP_OS_HYST,
+                                        data->temp_os_hyst);
+               }
+       }
+}
+
+void lm80_alarms(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct lm80_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               lm80_update_client(client);
+               results[0] = ALARMS_FROM_REG(data->alarms);
+               *nrels_mag = 1;
+       }
+}
+
+void lm80_fan_div(struct i2c_client *client, int operation, int ctl_name,
+                 int *nrels_mag, long *results)
+{
+       struct lm80_data *data = client->data;
+       int old;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               lm80_update_client(client);
+               results[0] = DIV_FROM_REG(data->fan_div[0]);
+               results[1] = DIV_FROM_REG(data->fan_div[1]);
+               results[2] = 2;
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               old = lm80_read_value(client, LM80_REG_FANDIV);
+               if (*nrels_mag >= 2) {
+                       data->fan_div[1] = DIV_TO_REG(results[1]);
+                       old = (old & 0xcf) | (data->fan_div[1] << 4);
+               }
+               if (*nrels_mag >= 1) {
+                       data->fan_div[0] = DIV_TO_REG(results[0]);
+                       old = (old & 0xf3) | (data->fan_div[0] << 2);
+                       lm80_write_value(client, LM80_REG_FANDIV, old);
+               }
+       }
+}
+
+static int __init sm_lm80_init(void)
+{
+       printk("lm80.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       return i2c_add_driver(&lm80_driver);
+}
+
+static void __exit sm_lm80_exit(void)
+{
+       i2c_del_driver(&lm80_driver);
+}
+
+
+
+MODULE_AUTHOR
+    ("Frodo Looijaard <frodol@dds.nl> and Philip Edelbrock <phil@netroedge.com>");
+MODULE_DESCRIPTION("LM80 driver");
+
+module_init(sm_lm80_init);
+module_exit(sm_lm80_exit);
--- linux-old/drivers/sensors/lm83.c    Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/lm83.c        Mon Dec 13 20:18:48 2004
@@ -0,0 +1,513 @@
+/*
+ * lm83.c - Part of lm_sensors, Linux kernel modules for hardware
+ *          monitoring
+ * Copyright (C) 2003  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
+ * temperatures (its own plus up to three external ones) with a 1 deg
+ * resolution and a 3-4 deg accuracy. Complete datasheet can be obtained
+ * from National's website at:
+ *   http://www.national.com/pf/LM/LM83.html
+ * Since the datasheet omits to give the chip stepping code, I give it
+ * here: 0x03 (at register 0xff).
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+/*
+ * Addresses to scan
+ * Address is selected using 2 three-level pins, resulting in 9 possible
+ * addresses.
+ */
+
+static unsigned short normal_i2c[] = { SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { 0x18, 0x1a, 0x29, 0x2b,
+       0x4c, 0x4e, SENSORS_I2C_END };
+static unsigned int normal_isa[] = { SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+/*
+ * Insmod parameters
+ */
+
+SENSORS_INSMOD_1(lm83);
+
+/*
+ * The LM83 registers
+ * Manufacturer ID is 0x01 for National Semiconductor.
+ */
+
+#define LM83_REG_R_MAN_ID        0xFE
+#define LM83_REG_R_CHIP_ID       0xFF
+#define LM83_REG_R_CONFIG        0x03
+#define LM83_REG_W_CONFIG        0x09
+#define LM83_REG_R_STATUS1       0x02
+#define LM83_REG_R_STATUS2       0x35
+#define LM83_REG_R_LOCAL_TEMP    0x00
+#define LM83_REG_R_LOCAL_HIGH    0x05
+#define LM83_REG_W_LOCAL_HIGH    0x0B
+#define LM83_REG_R_REMOTE1_TEMP  0x30
+#define LM83_REG_R_REMOTE1_HIGH  0x38
+#define LM83_REG_W_REMOTE1_HIGH  0x50
+#define LM83_REG_R_REMOTE2_TEMP  0x01
+#define LM83_REG_R_REMOTE2_HIGH  0x07
+#define LM83_REG_W_REMOTE2_HIGH  0x0D
+#define LM83_REG_R_REMOTE3_TEMP  0x31
+#define LM83_REG_R_REMOTE3_HIGH  0x3A
+#define LM83_REG_W_REMOTE3_HIGH  0x52
+#define LM83_REG_R_TCRIT         0x42
+#define LM83_REG_W_TCRIT         0x5A
+
+/*
+ * Conversions and various macros
+ * The LM83 uses signed 8-bit values.
+ */
+
+#define TEMP_FROM_REG(val)  ((val) > 127 ? (val) - 0x100 : (val))
+#define TEMP_TO_REG(val)    ((val) <= -50 ? -50 + 0x100 : \
+                             (val) >= 127 ? 127 : \
+                            (val) >= 0 ? (val) : \
+                             (val) + 0x100)
+
+static const u8 LM83_REG_R_TEMP[] = {
+       LM83_REG_R_LOCAL_TEMP,
+       LM83_REG_R_REMOTE1_TEMP,
+       LM83_REG_R_REMOTE2_TEMP,
+       LM83_REG_R_REMOTE3_TEMP
+};
+
+static const u8 LM83_REG_R_HIGH[] = {
+       LM83_REG_R_LOCAL_HIGH,
+       LM83_REG_R_REMOTE1_HIGH,
+       LM83_REG_R_REMOTE2_HIGH,
+       LM83_REG_R_REMOTE3_HIGH
+};
+
+static const u8 LM83_REG_W_HIGH[] = {
+       LM83_REG_W_LOCAL_HIGH,
+       LM83_REG_W_REMOTE1_HIGH,
+       LM83_REG_W_REMOTE2_HIGH,
+       LM83_REG_W_REMOTE3_HIGH
+};
+
+/*
+ * Functions declaration
+ */
+
+static int lm83_attach_adapter(struct i2c_adapter *adapter);
+static int lm83_detect(struct i2c_adapter *adapter, int address, unsigned
+       short flags, int kind);
+static int lm83_detach_client(struct i2c_client *client);
+static void lm83_update_client(struct i2c_client *client);
+static void lm83_temp(struct i2c_client *client, int operation, int
+       ctl_name, int *nrels_mag, long *results);
+static void lm83_tcrit(struct i2c_client *client, int operation, int
+       ctl_name, int *nrels_mag, long *results);
+static void lm83_alarms(struct i2c_client *client, int operation, int
+       ctl_name, int *nrels_mag, long *results);
+
+/*
+ * Driver data (common to all clients)
+ */
+ 
+static struct i2c_driver lm83_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "LM83 sensor driver",
+       .id             = I2C_DRIVERID_LM83,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = lm83_attach_adapter,
+       .detach_client  = lm83_detach_client,
+};
+
+/*
+ * Client data (each client gets its own)
+ */
+
+struct lm83_data
+{
+       struct i2c_client client;
+       int sysctl_id;
+
+       struct semaphore update_lock;
+       char valid; /* zero until following fields are valid */
+       unsigned long last_updated; /* in jiffies */
+
+       /* registers values */
+       u8 temp[4], temp_high[4], tcrit;
+       u16 alarms; /* bitvector, combined */
+};
+
+/*
+ * Proc entries
+ * These files are created for each detected LM83.
+ */
+
+/* -- SENSORS SYSCTL START -- */
+
+#define LM83_SYSCTL_LOCAL_TEMP    1200
+#define LM83_SYSCTL_REMOTE1_TEMP  1201
+#define LM83_SYSCTL_REMOTE2_TEMP  1202
+#define LM83_SYSCTL_REMOTE3_TEMP  1203
+#define LM83_SYSCTL_TCRIT         1208
+#define LM83_SYSCTL_ALARMS        1210
+
+#define LM83_ALARM_LOCAL_HIGH     0x0040
+#define LM83_ALARM_LOCAL_CRIT     0x0001
+#define LM83_ALARM_REMOTE1_HIGH   0x8000
+#define LM83_ALARM_REMOTE1_CRIT   0x0100
+#define LM83_ALARM_REMOTE1_OPEN   0x2000
+#define LM83_ALARM_REMOTE2_HIGH   0x0010
+#define LM83_ALARM_REMOTE2_CRIT   0x0002
+#define LM83_ALARM_REMOTE2_OPEN   0x0004
+#define LM83_ALARM_REMOTE3_HIGH   0x1000
+#define LM83_ALARM_REMOTE3_CRIT   0x0200
+#define LM83_ALARM_REMOTE3_OPEN   0x0400
+
+/* -- SENSORS SYSCTL END -- */
+
+
+static ctl_table lm83_dir_table_template[] =
+{
+       {LM83_SYSCTL_LOCAL_TEMP, "temp1", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &lm83_temp},
+       {LM83_SYSCTL_REMOTE1_TEMP, "temp2", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &lm83_temp},
+       {LM83_SYSCTL_REMOTE2_TEMP, "temp3", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &lm83_temp},
+       {LM83_SYSCTL_REMOTE3_TEMP, "temp4", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &lm83_temp},
+       {LM83_SYSCTL_TCRIT, "tcrit", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &lm83_tcrit},
+       {LM83_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &lm83_alarms},
+       {0}
+};
+
+/*
+ * Internal variables
+ */
+
+static int lm83_id = 0;
+
+/*
+ * Real code
+ */
+
+static int lm83_attach_adapter(struct i2c_adapter *adapter)
+{
+       return i2c_detect(adapter, &addr_data, lm83_detect);
+}
+
+/*
+ * The following function does more than just detection. If detection
+ * succeeds, it also registers the new chip.
+ */
+static int lm83_detect(struct i2c_adapter *adapter, int address, unsigned
+       short flags, int kind)
+{
+       struct i2c_client *new_client;
+       struct lm83_data *data;
+       int err = 0;
+       const char *type_name = "";
+       const char *client_name = "";
+
+#ifdef DEBUG
+       if (i2c_is_isa_adapter(adapter))
+       {
+               printk("lm83.o: Called for an ISA bus adapter, aborting.\n");
+               return 0;
+       }
+#endif
+
+       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
+       {
+#ifdef DEBUG
+               printk("lm83.o: I2C bus doesn't support byte read mode, "
+                      "skipping.\n");
+#endif
+               return 0;
+       }
+
+       if (!(data = kmalloc(sizeof(struct lm83_data), GFP_KERNEL)))
+       {
+               printk("lm83.o: Out of memory in lm83_detect (new_client).\n");
+               return -ENOMEM;
+       }
+
+       /*
+        * The common I2C client data is placed right before the
+        * LM83-specific data. The LM83-specific data is pointed to by the
+        * data field from the I2C client data.
+        */
+
+       new_client = &data->client;
+       new_client->addr = address;
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &lm83_driver;
+       new_client->flags = 0;
+
+       /*
+        * 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, LM83). 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 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))
+               {
+#ifdef DEBUG
+                       printk(KERN_DEBUG "lm83.o: Detection failed at 0x%02x.\n",
+                               address);
+#endif
+                       goto ERROR1;
+               }
+       }
+
+       if (kind <= 0) /* identification */
+       {
+               u8 man_id, chip_id;
+
+               man_id = i2c_smbus_read_byte_data(new_client, 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;
+               }
+       }
+
+       if (kind <= 0) /* identification failed */
+       {
+               printk("lm83.o: Unsupported chip.\n");
+               goto ERROR1;
+       }
+
+       if (kind == lm83)
+       {
+               type_name = "lm83";
+               client_name = "LM83 chip";
+       }
+       else
+       {
+               printk("lm83.o: Unknown kind %d.\n", kind);
+               goto ERROR1;
+       }
+       
+       /*
+        * OK, we got a valid chip so we can fill in the remaining client
+        * fields.
+        */
+
+       strcpy(new_client->name, client_name);
+       new_client->id = lm83_id++;
+       data->valid = 0;
+       init_MUTEX(&data->update_lock);
+
+       /*
+        * Tell the I2C layer a new client has arrived.
+        */
+
+       if ((err = i2c_attach_client(new_client)))
+       {
+#ifdef DEBUG
+               printk("lm83.o: Failed attaching client.\n");
+#endif
+               goto ERROR1;
+       }
+
+       /*
+        * Register a new directory entry.
+        */
+
+       if ((err = i2c_register_entry(new_client, type_name,
+            lm83_dir_table_template)) < 0)
+       {
+#ifdef DEBUG
+               printk("lm83.o: Failed registering directory entry.\n");
+#endif
+               goto ERROR2;
+       }
+       data->sysctl_id = err;
+
+       /*
+        * Initialize the LM83 chip
+        * (Nothing to do for this one.)
+        */
+
+       return 0;
+
+       ERROR2:
+       i2c_detach_client(new_client);
+       ERROR1:
+       kfree(data);
+       return err;
+}
+
+static int lm83_detach_client(struct i2c_client *client)
+{
+       int err;
+
+       i2c_deregister_entry(((struct lm83_data *) (client->data))->sysctl_id);
+       if ((err = i2c_detach_client(client)))
+       {
+               printk("lm83.o: Client deregistration failed, client not "
+                      "detached.\n");
+               return err;
+       }
+
+       kfree(client->data);
+       return 0;
+}
+
+static void lm83_update_client(struct i2c_client *client)
+{
+       struct lm83_data *data = client->data;
+
+       down(&data->update_lock);
+
+       if ((jiffies - data->last_updated > HZ * 2) ||
+           (jiffies < data->last_updated) || !data->valid)
+       {
+               int nr;
+#ifdef DEBUG
+               printk("lm83.o: Updating LM83 data.\n");
+#endif
+               for (nr = 0; nr < 4 ; nr++)
+               {
+                       data->temp[nr] =
+                               i2c_smbus_read_byte_data(client, LM83_REG_R_TEMP[nr]);
+                       data->temp_high[nr] =
+                               i2c_smbus_read_byte_data(client, LM83_REG_R_HIGH[nr]);
+               }
+               data->tcrit = i2c_smbus_read_byte_data(client, LM83_REG_R_TCRIT);
+               data->alarms =
+                       i2c_smbus_read_byte_data(client, LM83_REG_R_STATUS1) +
+                       (i2c_smbus_read_byte_data(client, LM83_REG_R_STATUS2) << 8);
+
+               data->last_updated = jiffies;
+               data->valid = 1;
+       }
+
+       up(&data->update_lock);
+}
+
+static void lm83_temp(struct i2c_client *client, int operation, int
+       ctl_name, int *nrels_mag, long *results)
+{
+       struct lm83_data *data = client->data;
+       int nr = ctl_name - LM83_SYSCTL_LOCAL_TEMP;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0; /* magnitude */
+       else if (operation == SENSORS_PROC_REAL_READ)
+       {
+               lm83_update_client(client);
+               results[0] = TEMP_FROM_REG(data->temp_high[nr]);
+               results[1] = TEMP_FROM_REG(data->temp[nr]);
+               *nrels_mag = 2;
+       }
+       else if (operation == SENSORS_PROC_REAL_WRITE)
+       {
+               if (*nrels_mag >= 1)
+               {
+                       data->temp_high[nr] = TEMP_TO_REG(results[0]);
+                       i2c_smbus_write_byte_data(client, LM83_REG_W_HIGH[nr],
+                                           data->temp_high[nr]);
+               }
+       }
+}
+
+static void lm83_tcrit(struct i2c_client *client, int operation, int
+       ctl_name, int *nrels_mag, long *results)
+{
+       struct lm83_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0; /* magnitude */
+       else if (operation == SENSORS_PROC_REAL_READ)
+       {
+               lm83_update_client(client);
+               results[0] = TEMP_FROM_REG(data->tcrit);
+               *nrels_mag = 1;
+       }
+       else if (operation == SENSORS_PROC_REAL_WRITE)
+       {
+               if (*nrels_mag >= 1)
+               {
+                       data->tcrit = TEMP_TO_REG(results[0]);
+                       i2c_smbus_write_byte_data(client, LM83_REG_W_TCRIT,
+                               data->tcrit);
+               }
+       }
+}
+
+static void lm83_alarms(struct i2c_client *client, int operation, int
+       ctl_name, int *nrels_mag, long *results)
+{
+       struct lm83_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0; /* magnitude */
+       else if (operation == SENSORS_PROC_REAL_READ)
+       {
+               lm83_update_client(client);
+               results[0] = data->alarms;
+               *nrels_mag = 1;
+       }
+}
+
+static int __init sm_lm83_init(void)
+{
+       printk(KERN_INFO "lm83.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       return i2c_add_driver(&lm83_driver);
+}
+
+static void __exit sm_lm83_exit(void)
+{
+       i2c_del_driver(&lm83_driver);
+}
+
+MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
+MODULE_DESCRIPTION("LM83 sensor driver");
+MODULE_LICENSE("GPL");
+
+module_init(sm_lm83_init);
+module_exit(sm_lm83_exit);
--- linux-old/drivers/sensors/lm85.c    Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/lm85.c        Mon Dec 13 20:18:49 2004
@@ -0,0 +1,2043 @@
+/*
+    lm85.c - Part of lm_sensors, Linux kernel modules for hardware
+             monitoring
+    Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl> 
+    Copyright (c) 2002, 2003  Philip Pokorny <ppokorny@penguincomputing.com>
+    Copyright (c) 2003        Margit Schubert-While <margitsw@t-online.de>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+    CHANGELOG
+
+    2002-11-13   First patch for LM85 functionality
+    2002-11-18   LM85 functionality mostly done
+    2002-12-02   Adding ADM1027 functionality
+    2002-12-06   Adding ADT7463 functionality
+    2003-01-09   Code cleanup.
+                 Save reserved bits in case they are implemented
+                    in a future chip.  (Solve problem with lockups
+                    on ADM1027 due to chip initialization)
+                 Added chip initialization bypass option
+    2003-02-12   Add THERM asserted counts for ADT7463
+                 Added #ifdef so we can compile against 2.6.5
+                    without updating i2c-ids.h
+    2003-02-17   Prepare for switch to 2.7.0 development
+                 Implement tmin_control for ADT7463
+                 Expose THERM asserted counts to /proc
+                 Code cleanup
+    2003-02-19   Working with Margit and LM_SENSORS developers
+    2003-02-23   Removed chip initialization entirely
+                 Scale voltages in driver at Margit's request
+                 Change PWM from 0-100% to 0-255 per LM sensors standard
+    2003-02-27   Documentation and code cleanups
+                 Added this CHANGELOG
+                 Print additional precision for temperatures and voltages
+                 Many thanks to Margit Schubert-While and Brandt xxxxxx
+                    for help testing this version
+    2003-02-28   More diagnostic messages regarding BIOS setup
+    2003-03-01   Added Interrupt mask register support.
+    2003-03-08   Fixed problem with pseudo 16-bit registers
+                 Cleaned up some compiler warnings.
+                 Fixed problem with Operating Point and THERM counting
+    2003-03-21   Initial support for EMC6D100 and EMC6D101 chips
+    2003-06-30   Add support for EMC6D100 extra voltage inputs.
+*/
+
+#include <linux/version.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+#include <linux/sensors_vid.h>
+
+#ifndef I2C_DRIVERID_LM85
+#define I2C_DRIVERID_LM85  1039
+#endif
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { SENSORS_I2C_END };
+static unsigned int normal_isa[] = { SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+/* Insmod parameters */
+SENSORS_INSMOD_5(lm85b, lm85c, adm1027, adt7463, emc6d100);
+
+/* Many LM85 constants specified below */
+
+/* The LM85 registers */
+#define LM85_REG_IN(nr) (0x20 + (nr))
+#define LM85_REG_IN_MIN(nr) (0x44 + (nr) * 2)
+#define LM85_REG_IN_MAX(nr) (0x45 + (nr) * 2)
+
+#define LM85_REG_TEMP(nr) (0x25 + (nr))
+#define LM85_REG_TEMP_MIN(nr) (0x4e + (nr) * 2)
+#define LM85_REG_TEMP_MAX(nr) (0x4f + (nr) * 2)
+
+/* Fan speeds are LSB, MSB (2 bytes) */
+#define LM85_REG_FAN(nr) (0x28 + (nr) *2)
+#define LM85_REG_FAN_MIN(nr) (0x54 + (nr) *2)
+
+#define LM85_REG_PWM(nr) (0x30 + (nr))
+
+#define ADT7463_REG_OPPOINT(nr) (0x33 + (nr))
+
+#define ADT7463_REG_TMIN_CTL1 0x36
+#define ADT7463_REG_TMIN_CTL2 0x37
+#define ADT7463_REG_TMIN_CTL  0x0136
+
+#define LM85_REG_DEVICE 0x3d
+#define LM85_REG_COMPANY 0x3e
+#define LM85_REG_VERSTEP 0x3f
+/* These are the recognized values for the above regs */
+#define LM85_DEVICE_ADX 0x27
+#define LM85_COMPANY_NATIONAL 0x01
+#define LM85_COMPANY_ANALOG_DEV 0x41
+#define LM85_COMPANY_SMSC 0x5c
+#define LM85_VERSTEP_VMASK 0xf0
+#define LM85_VERSTEP_SMASK 0x0f
+#define LM85_VERSTEP_GENERIC 0x60
+#define LM85_VERSTEP_LM85C 0x60
+#define LM85_VERSTEP_LM85B 0x62
+#define LM85_VERSTEP_ADM1027 0x60
+#define LM85_VERSTEP_ADT7463 0x62
+#define LM85_VERSTEP_EMC6D100_A0 0x60
+#define LM85_VERSTEP_EMC6D100_A1 0x61
+
+#define LM85_REG_CONFIG 0x40
+
+#define LM85_REG_ALARM1 0x41
+#define LM85_REG_ALARM2 0x42
+#define LM85_REG_ALARM  0x0141
+
+#define LM85_REG_VID 0x43
+
+/* Automated FAN control */
+#define LM85_REG_AFAN_CONFIG(nr) (0x5c + (nr))
+#define LM85_REG_AFAN_RANGE(nr) (0x5f + (nr))
+#define LM85_REG_AFAN_SPIKE1 0x62
+#define LM85_REG_AFAN_SPIKE2 0x63
+#define LM85_REG_AFAN_MINPWM(nr) (0x64 + (nr))
+#define LM85_REG_AFAN_LIMIT(nr) (0x67 + (nr))
+#define LM85_REG_AFAN_CRITICAL(nr) (0x6a + (nr))
+#define LM85_REG_AFAN_HYST1 0x6d
+#define LM85_REG_AFAN_HYST2 0x6e
+
+#define LM85_REG_TACH_MODE 0x74
+#define LM85_REG_SPINUP_CTL 0x75
+
+#define ADM1027_REG_TEMP_OFFSET(nr) (0x70 + (nr))
+#define ADM1027_REG_CONFIG2 0x73
+#define ADM1027_REG_INTMASK1 0x74
+#define ADM1027_REG_INTMASK2 0x75
+#define ADM1027_REG_INTMASK  0x0174
+#define ADM1027_REG_EXTEND_ADC1 0x76
+#define ADM1027_REG_EXTEND_ADC2 0x77
+#define ADM1027_REG_EXTEND_ADC  0x0176
+#define ADM1027_REG_CONFIG3 0x78
+#define ADM1027_REG_FAN_PPR 0x7b
+
+#define ADT7463_REG_THERM 0x79
+#define ADT7463_REG_THERM_LIMIT 0x7A
+#define ADT7463_REG_CONFIG4 0x7D
+
+#define EMC6D100_REG_SFR  0x7c
+#define EMC6D100_REG_ALARM3  0x7d
+#define EMC6D100_REG_CONF  0x7f
+#define EMC6D100_REG_INT_EN  0x80
+/* IN5, IN6 and IN7 */
+#define EMC6D100_REG_IN(nr)  (0x70 + ((nr)-5))
+#define EMC6D100_REG_IN_MIN(nr) (0x73 + ((nr)-5) * 2)
+#define EMC6D100_REG_IN_MAX(nr) (0x74 + ((nr)-5) * 2)
+
+/* Conversions. Rounding and limit checking is only done on the TO_REG 
+   variants. Note that you should be a bit careful with which arguments
+   these macros are called: arguments may be evaluated more than once.
+ */
+
+/* IN are scaled 1.000 == 0xc0, mag = 3 */
+#define IN_TO_REG(val)  (SENSORS_LIMIT((((val)*0xc0+500)/1000),0,255))
+#define INEXT_FROM_REG(val,ext) (((val)*1000 + (ext)*250 + 96)/0xc0)
+#define IN_FROM_REG(val) (INEXT_FROM_REG(val,0))
+
+/* IN are scaled acording to built-in resistors */
+static int lm85_scaling[] = {  /* .001 Volts */
+               2500, 2250, 3300, 5000, 12000,
+               3300, 1500, 1800,       /* EMC6D100 */
+       };
+#define SCALE(val,from,to) (((val)*(to) + ((from)/2))/(from))
+#define INS_TO_REG(n,val)  (SENSORS_LIMIT(SCALE(val,lm85_scaling[n],192),0,255))
+#define INSEXT_FROM_REG(n,val,ext) (SCALE((val)*4 + (ext),192*4,lm85_scaling[n]))
+#define INS_FROM_REG(n,val) (INSEXT_FROM_REG(n,val,0))
+
+/* FAN speed is measured using 90kHz clock */
+#define FAN_TO_REG(val)  (SENSORS_LIMIT( (val)<=0?0: 5400000/(val),0,65534))
+#define FAN_FROM_REG(val) ((val)==0?-1:(val)==0xffff?0:5400000/(val))
+
+/* Temperature is reported in .01 degC increments */
+#define TEMP_TO_REG(val) (SENSORS_LIMIT(((val)+50)/100,-127,127))
+#define TEMPEXT_FROM_REG(val,ext) ((val)*100 + (ext)*25)
+#define TEMP_FROM_REG(val) (TEMPEXT_FROM_REG(val,0))
+#define EXTTEMP_TO_REG(val) (SENSORS_LIMIT((val)/25,-127,127))
+#define OPPOINT_TO_REG(val) (SENSORS_LIMIT(val,-127,127))
+#define OPPOINT_FROM_REG(val) (val)
+
+#define PWM_TO_REG(val) (SENSORS_LIMIT(val,0,255))
+#define PWM_FROM_REG(val) (val)
+
+#define EXT_FROM_REG(val,sensor) (((val)>>(sensor * 2))&0x03)
+
+/* ZONEs have the following parameters:
+ *    Limit (low) temp,           1. degC
+ *    Hysteresis (below limit),   1. degC (0-15)
+ *    Range of speed control,     .1 degC (2-80)
+ *    Critical (high) temp,       1. degC
+ *
+ * FAN PWMs have the following parameters:
+ *    Reference Zone,                 1, 2, 3, etc.
+ *    Spinup time,                    .05 sec
+ *    PWM value at limit/low temp,    1 count
+ *    PWM Frequency,                  1. Hz
+ *    PWM is Min or OFF below limit,  flag
+ *    Invert PWM output,              flag
+ *
+ * Some chips filter the temp, others the fan.
+ *    Filter constant (or disabled)   .1 seconds
+ */
+
+/* These are the zone temperature range encodings */
+static int lm85_range_map[] = {   /* .1 degC */
+                20,  25,  33,  40,  50,  66,
+                80, 100, 133, 160, 200, 266,
+               320, 400, 533, 800
+       };
+static int RANGE_TO_REG( int range )
+{
+       int i;
+
+       if( range >= lm85_range_map[15] ) { return 15 ; }
+       for( i = 0 ; i < 15 ; ++i )
+               if( range <= lm85_range_map[i] )
+                       break ;
+       return( i & 0x0f );
+}
+#define RANGE_FROM_REG(val) (lm85_range_map[(val)&0x0f])
+
+/* These are the Acoustic Enhancement, or Temperature smoothing encodings
+ * NOTE: The enable/disable bit is INCLUDED in these encodings as the
+ *       MSB (bit 3, value 8).  If the enable bit is 0, the encoded value
+ *       is ignored, or set to 0.
+ */
+static int lm85_smooth_map[] = {  /* .1 sec */
+               350, 176, 118,  70,  44,   30,   16,    8
+/*    35.4 *    1/1, 1/2, 1/3, 1/5, 1/8, 1/12, 1/24, 1/48  */
+       };
+static int SMOOTH_TO_REG( int smooth )
+{
+       int i;
+
+       if( smooth <= 0 ) { return 0 ; }  /* Disabled */
+       for( i = 0 ; i < 7 ; ++i )
+               if( smooth >= lm85_smooth_map[i] )
+                       break ;
+       return( (i & 0x07) | 0x08 );
+}
+#define SMOOTH_FROM_REG(val) ((val)&0x08?lm85_smooth_map[(val)&0x07]:0)
+
+/* These are the fan spinup delay time encodings */
+static int lm85_spinup_map[] = {  /* .1 sec */
+               0, 1, 2, 4, 7, 10, 20, 40
+       };
+static int SPINUP_TO_REG( int spinup )
+{
+       int i;
+
+       if( spinup >= lm85_spinup_map[7] ) { return 7 ; }
+       for( i = 0 ; i < 7 ; ++i )
+               if( spinup <= lm85_spinup_map[i] )
+                       break ;
+       return( i & 0x07 );
+}
+#define SPINUP_FROM_REG(val) (lm85_spinup_map[(val)&0x07])
+
+/* These are the PWM frequency encodings */
+static int lm85_freq_map[] = { /* .1 Hz */
+               100, 150, 230, 300, 380, 470, 620, 980
+       };
+static int FREQ_TO_REG( int freq )
+{
+       int i;
+
+       if( freq >= lm85_freq_map[7] ) { return 7 ; }
+       for( i = 0 ; i < 7 ; ++i )
+               if( freq <= lm85_freq_map[i] )
+                       break ;
+       return( i & 0x07 );
+}
+#define FREQ_FROM_REG(val) (lm85_freq_map[(val)&0x07])
+
+/* Since we can't use strings, I'm abusing these numbers
+ *   to stand in for the following meanings:
+ *      1 -- PWM responds to Zone 1
+ *      2 -- PWM responds to Zone 2
+ *      3 -- PWM responds to Zone 3
+ *     23 -- PWM responds to the higher temp of Zone 2 or 3
+ *    123 -- PWM responds to highest of Zone 1, 2, or 3
+ *      0 -- PWM is always at 0% (ie, off)
+ *     -1 -- PWM is always at 100%
+ *     -2 -- PWM responds to manual control
+ */
+static int lm85_zone_map[] = { 1, 2, 3, -1, 0, 23, 123, -2 };
+static int ZONE_TO_REG( int zone )
+{
+       int i;
+
+       for( i = 0 ; i <= 7 ; ++i )
+               if( zone == lm85_zone_map[i] )
+                       break ;
+       if( i > 7 )   /* Not found. */
+               i = 3;  /* Always 100% */
+       return( (i & 0x07)<<5 );
+}
+#define ZONE_FROM_REG(val) (lm85_zone_map[((val)>>5)&0x07])
+
+#define HYST_TO_REG(val) (SENSORS_LIMIT((-(val)+5)/10,0,15))
+#define HYST_FROM_REG(val) (-(val)*10)
+
+#define OFFSET_TO_REG(val) (SENSORS_LIMIT((val)/25,-127,127))
+#define OFFSET_FROM_REG(val) ((val)*25)
+
+#define PPR_MASK(fan) (0x03<<(fan *2))
+#define PPR_TO_REG(val,fan) (SENSORS_LIMIT((val)-1,0,3)<<(fan *2))
+#define PPR_FROM_REG(val,fan) ((((val)>>(fan * 2))&0x03)+1)
+
+/* sensors_vid.h defines vid_from_reg() */
+#define VID_FROM_REG(val,vrm) (vid_from_reg((val),(vrm)))
+
+#define ALARMS_FROM_REG(val) (val)
+
+/* When converting to REG, we need to fixup the carry-over bit */
+#define INTMASK_FROM_REG(val) (val)
+#define INTMASK_TO_REG(val) (SENSORS_LIMIT((val)|((val)&0xff00?0x80:0),0,65535))
+
+/* Unlike some other drivers we DO NOT set initial limits.  Use
+ * the config file to set limits.  Some users have reported
+ * motherboards shutting down when we set limits in a previous
+ * version of this driver.  This may be caused by APM/ACPI
+ * detecting an out-of-limit condition when we had the wrong
+ * limits set.
+ */
+
+/* Typically used with Pentium 4 systems v9.1 VRM spec */
+#define LM85_INIT_VRM  91
+
+/* Chip sampling rates
+ *
+ * Some sensors are not updated more frequently than once per second
+ *    so it doesn't make sense to read them more often than that.
+ *    We cache the results and return the saved data if the driver
+ *    is called again before a second has elapsed.
+ *
+ * Also, there is significant configuration data for this chip
+ *    given the automatic PWM fan control that is possible.  There
+ *    are about 47 bytes of config data to only 22 bytes of actual
+ *    readings.  So, we keep the config data up to date in the cache
+ *    when it is written and only sample it once every 5 *minutes*
+ */
+#define LM85_DATA_INTERVAL  (1 * HZ)
+#define LM85_CONFIG_INTERVAL  (5 * 60 * HZ)
+
+/* For each registered LM85, we need to keep some data in memory. That
+   data is pointed to by client->data. The structure itself is
+   dynamically allocated, when a new lm85 client is allocated. */
+
+/* LM85 can automatically adjust fan speeds based on temperature
+ * This structure encapsulates an entire Zone config.  There are
+ * three zones (one for each temperature input) on the lm85
+ */
+struct lm85_zone {
+       s8 limit;       /* Low temp limit */
+       u8 hyst;        /* Low limit hysteresis. (0-15) */
+       u8 range;       /* Temp range, encoded */
+       s8 critical;    /* "All fans ON" temp limit */
+};
+
+struct lm85_autofan {
+       u8 config;      /* Register value */
+       u8 freq;        /* PWM frequency, encoded */
+       u8 min_pwm;     /* Minimum PWM value, encoded */
+       u8 min_off;     /* Min PWM or OFF below "limit", flag */
+};
+
+struct lm85_data {
+       struct i2c_client client;
+       struct semaphore lock;
+       int sysctl_id;
+       enum chips type;
+
+       struct semaphore update_lock;
+       int valid;              /* !=0 if following fields are valid */
+       unsigned long last_reading;     /* In jiffies */
+       unsigned long last_config;      /* In jiffies */
+
+       u8 in[8];               /* Register value */
+       u8 in_max[8];           /* Register value */
+       u8 in_min[8];           /* Register value */
+       s8 temp[3];             /* Register value */
+       s8 temp_min[3];         /* Register value */
+       s8 temp_max[3];         /* Register value */
+       s8 temp_offset[3];      /* Register value */
+       u16 fan[4];             /* Register value */
+       u16 fan_min[4];         /* Register value */
+       u8 pwm[3];              /* Register value */
+       u8 spinup_ctl;          /* Register encoding, combined */
+       u8 tach_mode;           /* Register encoding, combined */
+       u16 extend_adc;         /* Register value */
+       u8 fan_ppr;             /* Register value */
+       u8 smooth[3];           /* Register encoding */
+       u8 vid;                 /* Register value */
+       u8 vrm;                 /* VRM version */
+       u8 syncpwm3;            /* Saved PWM3 for TACH 2,3,4 config */
+       s8 oppoint[3];          /* Register value */
+       u16 tmin_ctl;           /* Register value */
+       long therm_total;       /* Cummulative therm count */
+       long therm_ovfl;        /* Count of therm overflows */
+       u8 therm_limit;         /* Register value */
+       u32 alarms;             /* Register encoding, combined */
+       u32 alarm_mask;         /* Register encoding, combined */
+       struct lm85_autofan autofan[3];
+       struct lm85_zone zone[3];
+};
+
+static int lm85_attach_adapter(struct i2c_adapter *adapter);
+static int lm85_detect(struct i2c_adapter *adapter, int address,
+                       unsigned short flags, int kind);
+static int lm85_detach_client(struct i2c_client *client);
+static int lm85_read_value(struct i2c_client *client, u16 register);
+static int lm85_write_value(struct i2c_client *client, u16 register, int value);
+static void lm85_update_client(struct i2c_client *client);
+static void lm85_init_client(struct i2c_client *client);
+
+
+static void lm85_in(struct i2c_client *client, int operation, int ctl_name,
+                       int *nrels_mag, long *results);
+static void lm85_fan(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void lm85_temp(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void lm85_vid(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void lm85_vrm(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void lm85_alarms(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void lm85_pwm(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void lm85_zone(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void lm85_pwm_config(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void lm85_pwm_zone(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void lm85_smooth(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+
+static void lm85_spinup_ctl(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void lm85_tach_mode(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+
+static void adm1027_tach_mode(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void adm1027_temp_offset(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void adm1027_fan_ppr(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void adm1027_alarm_mask(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+
+static void adt7463_tmin_ctl(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void adt7463_therm_signal(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+
+static void emc6d100_in(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+
+static struct i2c_driver lm85_driver = {
+       .owner          = THIS_MODULE,
+       .name           =  "LM85 compatible sensor driver",
+       .id             = I2C_DRIVERID_LM85,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = &lm85_attach_adapter,
+       .detach_client  = &lm85_detach_client,
+};
+
+/* Unique ID assigned to each LM85 detected */
+static int lm85_id = 0;
+
+/* -- SENSORS SYSCTL START -- */
+/* Common parameters */
+#define LM85_SYSCTL_IN0                1000
+#define LM85_SYSCTL_IN1                1001
+#define LM85_SYSCTL_IN2                1002
+#define LM85_SYSCTL_IN3                1003
+#define LM85_SYSCTL_IN4                1004
+#define LM85_SYSCTL_FAN1               1005
+#define LM85_SYSCTL_FAN2               1006
+#define LM85_SYSCTL_FAN3               1007
+#define LM85_SYSCTL_FAN4               1008
+#define LM85_SYSCTL_TEMP1              1009
+#define LM85_SYSCTL_TEMP2              1010
+#define LM85_SYSCTL_TEMP3              1011
+#define LM85_SYSCTL_VID                1012
+#define LM85_SYSCTL_ALARMS             1013
+#define LM85_SYSCTL_PWM1               1014
+#define LM85_SYSCTL_PWM2               1015
+#define LM85_SYSCTL_PWM3               1016
+#define LM85_SYSCTL_VRM                1017
+#define LM85_SYSCTL_PWM_CFG1           1019
+#define LM85_SYSCTL_PWM_CFG2           1020
+#define LM85_SYSCTL_PWM_CFG3           1021
+#define LM85_SYSCTL_PWM_ZONE1          1022
+#define LM85_SYSCTL_PWM_ZONE2          1023
+#define LM85_SYSCTL_PWM_ZONE3          1024
+#define LM85_SYSCTL_ZONE1              1025
+#define LM85_SYSCTL_ZONE2              1026
+#define LM85_SYSCTL_ZONE3              1027
+#define LM85_SYSCTL_SMOOTH1            1028
+#define LM85_SYSCTL_SMOOTH2            1029
+#define LM85_SYSCTL_SMOOTH3            1030
+
+/* Vendor specific values */
+#define LM85_SYSCTL_SPINUP_CTL         1100
+#define LM85_SYSCTL_TACH_MODE          1101
+
+/* Analog Devices variant of the LM85 */
+#define ADM1027_SYSCTL_TACH_MODE       1200
+#define ADM1027_SYSCTL_TEMP_OFFSET1    1201
+#define ADM1027_SYSCTL_TEMP_OFFSET2    1202
+#define ADM1027_SYSCTL_TEMP_OFFSET3    1203
+#define ADM1027_SYSCTL_FAN_PPR         1204
+#define ADM1027_SYSCTL_ALARM_MASK      1205
+
+/* Analog Devices variant of the LM85/ADM1027 */
+#define ADT7463_SYSCTL_TMIN_CTL1       1300
+#define ADT7463_SYSCTL_TMIN_CTL2       1301
+#define ADT7463_SYSCTL_TMIN_CTL3       1302
+#define ADT7463_SYSCTL_THERM_SIGNAL    1303
+
+/* SMSC variant of the LM85 */
+#define EMC6D100_SYSCTL_IN5            1400
+#define EMC6D100_SYSCTL_IN6            1401
+#define EMC6D100_SYSCTL_IN7            1402
+
+#define LM85_ALARM_IN0          0x0001
+#define LM85_ALARM_IN1          0x0002
+#define LM85_ALARM_IN2          0x0004
+#define LM85_ALARM_IN3          0x0008
+#define LM85_ALARM_TEMP1        0x0010
+#define LM85_ALARM_TEMP2        0x0020
+#define LM85_ALARM_TEMP3        0x0040
+#define LM85_ALARM_ALARM2       0x0080
+#define LM85_ALARM_IN4          0x0100
+#define LM85_ALARM_RESERVED     0x0200
+#define LM85_ALARM_FAN1         0x0400
+#define LM85_ALARM_FAN2         0x0800
+#define LM85_ALARM_FAN3         0x1000
+#define LM85_ALARM_FAN4         0x2000
+#define LM85_ALARM_TEMP1_FAULT  0x4000
+#define LM85_ALARM_TEMP3_FAULT 0x08000
+#define LM85_ALARM_IN6         0x10000
+#define LM85_ALARM_IN7         0x20000
+#define LM85_ALARM_IN5         0x40000
+/* -- SENSORS SYSCTL END -- */
+
+/* The /proc/sys entries */
+/* These files are created for each detected LM85. This is just a template;
+ *    The actual list is built from this and additional per-chip
+ *    custom lists below.  Note the XXX_LEN macros.  These must be
+ *    compile time constants because they will be used to allocate
+ *    space for the final template passed to i2c_register_entry.
+ *    We depend on the ability of GCC to evaluate expressions at
+ *    compile time to turn these expressions into compile time
+ *    constants, but this can generate a warning.
+ */
+static ctl_table lm85_common[] = {
+       {LM85_SYSCTL_IN0, "in0", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &lm85_in},
+       {LM85_SYSCTL_IN1, "in1", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &lm85_in},
+       {LM85_SYSCTL_IN2, "in2", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &lm85_in},
+       {LM85_SYSCTL_IN3, "in3", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &lm85_in},
+       {LM85_SYSCTL_IN4, "in4", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &lm85_in},
+       {LM85_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &lm85_fan},
+       {LM85_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &lm85_fan},
+       {LM85_SYSCTL_FAN3, "fan3", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &lm85_fan},
+       {LM85_SYSCTL_FAN4, "fan4", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &lm85_fan},
+       {LM85_SYSCTL_TEMP1, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &lm85_temp},
+       {LM85_SYSCTL_TEMP2, "temp2", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &lm85_temp},
+       {LM85_SYSCTL_TEMP3, "temp3", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &lm85_temp},
+       {LM85_SYSCTL_VID, "vid", NULL, 0, 0444, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &lm85_vid},
+       {LM85_SYSCTL_VRM, "vrm", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &lm85_vrm},
+       {LM85_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &lm85_alarms},
+       {LM85_SYSCTL_PWM1, "pwm1", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &lm85_pwm},
+       {LM85_SYSCTL_PWM2, "pwm2", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &lm85_pwm},
+       {LM85_SYSCTL_PWM3, "pwm3", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &lm85_pwm},
+       {LM85_SYSCTL_PWM_CFG1, "pwm1_cfg", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &lm85_pwm_config},
+       {LM85_SYSCTL_PWM_CFG2, "pwm2_cfg", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &lm85_pwm_config},
+       {LM85_SYSCTL_PWM_CFG3, "pwm3_cfg", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &lm85_pwm_config},
+       {LM85_SYSCTL_PWM_ZONE1, "pwm1_zone", NULL, 0, 0644, NULL,
+               &i2c_proc_real, &i2c_sysctl_real, NULL, &lm85_pwm_zone},
+       {LM85_SYSCTL_PWM_ZONE2, "pwm2_zone", NULL, 0, 0644, NULL,
+               &i2c_proc_real, &i2c_sysctl_real, NULL, &lm85_pwm_zone},
+       {LM85_SYSCTL_PWM_ZONE3, "pwm3_zone", NULL, 0, 0644, NULL,
+               &i2c_proc_real, &i2c_sysctl_real, NULL, &lm85_pwm_zone},
+       {LM85_SYSCTL_ZONE1, "zone1", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &lm85_zone},
+       {LM85_SYSCTL_ZONE2, "zone2", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &lm85_zone},
+       {LM85_SYSCTL_ZONE3, "zone3", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &lm85_zone},
+       {LM85_SYSCTL_SMOOTH1, "smooth1", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &lm85_smooth},
+       {LM85_SYSCTL_SMOOTH2, "smooth2", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &lm85_smooth},
+       {LM85_SYSCTL_SMOOTH3, "smooth3", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &lm85_smooth},
+       {0}
+};
+#define CTLTBL_COMMON (sizeof(lm85_common)/sizeof(lm85_common[0]))
+
+/* NOTE: tach_mode is a shared name, but implemented with
+ *   different functions
+ */
+static ctl_table lm85_specific[] = {
+       {LM85_SYSCTL_SPINUP_CTL, "spinup_ctl", NULL, 0, 0644, NULL,
+               &i2c_proc_real, &i2c_sysctl_real, NULL, &lm85_spinup_ctl},
+       {LM85_SYSCTL_TACH_MODE, "tach_mode", NULL, 0, 0644, NULL,
+               &i2c_proc_real, &i2c_sysctl_real, NULL, &lm85_tach_mode},
+/*     {0} The doc generator needs this. */
+};
+#define CTLTBL_LM85 (sizeof(lm85_specific)/sizeof(lm85_specific[0]))
+
+static ctl_table adm1027_specific[] = {
+       {ADM1027_SYSCTL_TACH_MODE, "tach_mode", NULL, 0, 0644, NULL,
+               &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1027_tach_mode},
+       {ADM1027_SYSCTL_TEMP_OFFSET1, "temp1_offset", NULL, 0, 0644, NULL,
+               &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1027_temp_offset},
+       {ADM1027_SYSCTL_TEMP_OFFSET2, "temp2_offset", NULL, 0, 0644, NULL,
+               &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1027_temp_offset},
+       {ADM1027_SYSCTL_TEMP_OFFSET3, "temp3_offset", NULL, 0, 0644, NULL,
+               &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1027_temp_offset},
+       {ADM1027_SYSCTL_FAN_PPR, "fan_ppr", NULL, 0, 0644, NULL,
+               &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1027_fan_ppr},
+       {ADM1027_SYSCTL_ALARM_MASK, "alarm_mask", NULL, 0, 0644, NULL,
+               &i2c_proc_real, &i2c_sysctl_real, NULL, &adm1027_alarm_mask},
+/*     {0} The doc generator needs this. */
+};
+#define CTLTBL_ADM1027 (sizeof(adm1027_specific)/sizeof(adm1027_specific[0]))
+
+static ctl_table adt7463_specific[] = {
+       {ADT7463_SYSCTL_TMIN_CTL1, "tmin_ctl1", NULL, 0, 0644, NULL,
+               &i2c_proc_real, &i2c_sysctl_real, NULL, &adt7463_tmin_ctl},
+       {ADT7463_SYSCTL_TMIN_CTL2, "tmin_ctl2", NULL, 0, 0644, NULL,
+               &i2c_proc_real, &i2c_sysctl_real, NULL, &adt7463_tmin_ctl},
+       {ADT7463_SYSCTL_TMIN_CTL3, "tmin_ctl3", NULL, 0, 0644, NULL,
+               &i2c_proc_real, &i2c_sysctl_real, NULL, &adt7463_tmin_ctl},
+       {ADT7463_SYSCTL_THERM_SIGNAL, "therm_signal", NULL, 0, 0644, NULL,
+               &i2c_proc_real, &i2c_sysctl_real, NULL, &adt7463_therm_signal},
+/*     {0} The doc generator needs this. */
+};
+#define CTLTBL_ADT7463 (sizeof(adt7463_specific)/sizeof(adt7463_specific[0]))
+
+static ctl_table emc6d100_specific[] = {
+       {EMC6D100_SYSCTL_IN5, "in5", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &emc6d100_in},
+       {EMC6D100_SYSCTL_IN6, "in6", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &emc6d100_in},
+       {EMC6D100_SYSCTL_IN7, "in7", NULL, 0, 0644, NULL, &i2c_proc_real,
+               &i2c_sysctl_real, NULL, &emc6d100_in},
+/*     {0} The doc generator needs this. */
+};
+#define CTLTBL_EMC6D100 (sizeof(emc6d100_specific)/sizeof(emc6d100_specific[0]))
+
+
+#define MAX2(a,b) ((a)>(b)?(a):(b))
+#define MAX3(a,b,c) ((a)>(b)?MAX2((a),(c)):MAX2((b),(c)))
+#define MAX4(a,b,c,d) ((a)>(b)?MAX3((a),(c),(d)):MAX3((b),(c),(d)))
+
+#define CTLTBL_MAX (CTLTBL_COMMON + MAX3(CTLTBL_LM85, CTLTBL_ADM1027+CTLTBL_ADT7463, CTLTBL_EMC6D100))
+
+/* This function is called when:
+     * lm85_driver is inserted (when this module is loaded), for each
+       available adapter
+     * when a new adapter is inserted (and lm85_driver is still present) */
+int lm85_attach_adapter(struct i2c_adapter *adapter)
+{
+       return i2c_detect(adapter, &addr_data, lm85_detect);
+}
+
+/* This function is called by i2c_detect */
+int lm85_detect(struct i2c_adapter *adapter, int address,
+               unsigned short flags, int kind)
+{
+       int i;
+       int company, verstep ;
+       struct i2c_client *new_client;
+       struct lm85_data *data;
+       int err = 0;
+       const char *type_name = "";
+       struct ctl_table template[CTLTBL_MAX] ;
+       int template_used ;
+
+       if (i2c_is_isa_adapter(adapter)) {
+               /* This chip has no ISA interface */
+               goto ERROR0 ;
+       };
+
+       if (!i2c_check_functionality(adapter,
+                                       I2C_FUNC_SMBUS_BYTE_DATA)) {
+               /* We need to be able to do byte I/O */
+               goto ERROR0 ;
+       };
+
+       /* OK. For now, we presume we have a valid client. We now create the
+          client structure, even though we cannot fill it completely yet.
+          But it allows us to access lm85_{read,write}_value. */
+
+       if (!(data = kmalloc(sizeof(struct lm85_data), GFP_KERNEL))) {
+               err = -ENOMEM;
+               goto ERROR0;
+       }
+
+       new_client = &data->client;
+       new_client->addr = address;
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &lm85_driver;
+       new_client->flags = 0;
+
+       /* Now, we do the remaining detection. */
+
+       company = lm85_read_value(new_client, LM85_REG_COMPANY);
+       verstep = lm85_read_value(new_client, LM85_REG_VERSTEP);
+
+#ifdef DEBUG
+       printk("lm85: Detecting device at %d,0x%02x with"
+               " COMPANY: 0x%02x and VERSTEP: 0x%02x\n",
+               i2c_adapter_id(new_client->adapter), new_client->addr,
+               company, verstep
+           );
+#endif
+
+       /* If auto-detecting, Determine the chip type. */
+       if (kind <= 0) {
+#ifdef DEBUG
+               printk("lm85: Autodetecting device at %d,0x%02x ...\n",
+                       i2c_adapter_id(adapter), address );
+#endif
+               if( company == LM85_COMPANY_NATIONAL
+                   && verstep == LM85_VERSTEP_LM85C ) {
+                       kind = lm85c ;
+               } else if( company == LM85_COMPANY_NATIONAL
+                   && verstep == LM85_VERSTEP_LM85B ) {
+                       kind = lm85b ;
+               } else if( company == LM85_COMPANY_NATIONAL
+                   && (verstep & LM85_VERSTEP_VMASK) == LM85_VERSTEP_GENERIC) {
+                       printk("lm85: Detected National Semiconductor chip\n");
+                       printk("lm85: Unrecgonized version/stepping 0x%02x"
+                           " Defaulting to Generic LM85.\n", verstep );
+                       kind = any_chip ;
+               } else if( company == LM85_COMPANY_ANALOG_DEV
+                   && verstep == LM85_VERSTEP_ADM1027 ) {
+                       kind = adm1027 ;
+               } else if( company == LM85_COMPANY_ANALOG_DEV
+                   && verstep == LM85_VERSTEP_ADT7463 ) {
+                       kind = adt7463 ;
+               } else if( company == LM85_COMPANY_ANALOG_DEV
+                   && (verstep & LM85_VERSTEP_VMASK) == LM85_VERSTEP_GENERIC) {
+                       printk("lm85: Detected Analog Devices chip\n");
+                       printk("lm85: Unrecgonized version/stepping 0x%02x"
+                           " Defaulting to Generic LM85.\n", verstep );
+                       kind = any_chip ;
+               } else if( company == LM85_COMPANY_SMSC
+                   && (verstep == LM85_VERSTEP_EMC6D100_A0
+                        || verstep == LM85_VERSTEP_EMC6D100_A1) ) {
+                       /* Unfortunately, we can't tell a '100 from a '101
+                        *   from the registers.  Since a '101 is a '100
+                        *   in a package with fewer pins and therefore no
+                        *   3.3V, 1.5V or 1.8V inputs, perhaps if those
+                        *   inputs read 0, then it's a '101.
+                        */
+                       kind = emc6d100 ;
+               } else if( company == LM85_COMPANY_SMSC
+                   && (verstep & LM85_VERSTEP_VMASK) == LM85_VERSTEP_GENERIC) {
+                       printk("lm85: Detected SMSC chip\n");
+                       printk("lm85: Unrecognized version/stepping 0x%02x"
+                           " Defaulting to Generic LM85.\n", verstep );
+                       kind = any_chip ;
+               } else if( kind == any_chip
+                   && (verstep & LM85_VERSTEP_VMASK) == LM85_VERSTEP_GENERIC) {
+                       printk("lm85: Generic LM85 Version 6 detected\n");
+                       /* Leave kind as "any_chip" */
+               } else {
+#ifdef DEBUG
+                       printk("lm85: Autodetection failed\n");
+#endif
+                       /* Not an LM85 ... */
+                       if( kind == any_chip ) {  /* User used force=x,y */
+                           printk("lm85: Generic LM85 Version 6 not"
+                               " found at %d,0x%02x. Try force_lm85c.\n",
+                               i2c_adapter_id(adapter), address );
+                       }
+                       err = 0 ;
+                       goto ERROR1;
+               }
+       }
+
+       /* Fill in the chip specific driver values */
+       switch (kind) {
+       case any_chip :
+               type_name = "lm85";
+               strcpy(new_client->name, "Generic LM85");
+               template_used = 0 ;
+               break ;
+       case lm85b :
+               type_name = "lm85b";
+               strcpy(new_client->name, "National LM85-B");
+               memcpy( template, lm85_specific, sizeof(lm85_specific) );
+               template_used = CTLTBL_LM85 ;
+               break ;
+       case lm85c :
+               type_name = "lm85c";
+               strcpy(new_client->name, "National LM85-C");
+               memcpy( template, lm85_specific, sizeof(lm85_specific) );
+               template_used = CTLTBL_LM85 ;
+               break ;
+       case adm1027 :
+               type_name = "adm1027";
+               strcpy(new_client->name, "Analog Devices ADM1027");
+               memcpy( template, adm1027_specific, sizeof(adm1027_specific) );
+               template_used = CTLTBL_ADM1027 ;
+               break ;
+       case adt7463 :
+               type_name = "adt7463";
+               strcpy(new_client->name, "Analog Devices ADT7463");
+               memcpy( template, adt7463_specific, sizeof(adt7463_specific) );
+               template_used = CTLTBL_ADT7463 ;
+               memcpy( template+template_used, adm1027_specific, sizeof(adm1027_specific) );
+               template_used += CTLTBL_ADM1027 ;
+               break ;
+       case emc6d100 :
+               type_name = "emc6d100";
+               strcpy(new_client->name, "SMSC EMC6D100");
+               memcpy(template, emc6d100_specific, sizeof(emc6d100_specific));
+               template_used = CTLTBL_EMC6D100 ;
+               break ;
+       default :
+               printk("lm85: Internal error, invalid kind (%d)!", kind);
+               err = -EFAULT ;
+               goto ERROR1;
+       }
+
+       /* Fill in the remaining client fields */
+       new_client->id = lm85_id++;
+       printk("lm85: Assigning ID %d to %s at %d,0x%02x\n",
+               new_client->id, new_client->name,
+               i2c_adapter_id(new_client->adapter),
+               new_client->addr
+           );
+
+       /* Housekeeping values */
+       data->type = kind;
+       data->valid = 0;
+
+       /* Set the VRM version */
+       data->vrm = LM85_INIT_VRM ;
+
+       /* Zero the accumulators */
+       data->therm_total = 0;
+       data->therm_ovfl = 0;
+
+       init_MUTEX(&data->update_lock);
+
+       /* Initialize the LM85 chip */
+       lm85_init_client(new_client);
+
+       /* Tell the I2C layer a new client has arrived */
+       if ((err = i2c_attach_client(new_client)))
+               goto ERROR1;
+
+       /* Finish out the template */
+       memcpy( template + template_used, lm85_common, sizeof(lm85_common) );
+
+       /* Register a new directory entry with module sensors */
+       if ((i = i2c_register_entry(new_client,
+                                       type_name,
+                                       template)) < 0) {
+               err = i;
+               goto ERROR2;
+       }
+       data->sysctl_id = i;
+
+       return 0;
+
+       /* Error out and cleanup code */
+    ERROR2:
+       i2c_detach_client(new_client);
+    ERROR1:
+       kfree(data);
+    ERROR0:
+       return err;
+}
+
+int lm85_detach_client(struct i2c_client *client)
+{
+       int err;
+       int id ;
+
+       id = client->id;
+       i2c_deregister_entry(((struct lm85_data *)(client->data))->sysctl_id);
+
+       if ((err = i2c_detach_client(client))) {
+               printk("lm85(%d): Client deregistration failed,"
+                       " client not detached.\n", id );
+               return err;
+       }
+
+       kfree(client->data);
+
+       return 0;
+}
+
+int lm85_read_value(struct i2c_client *client, u16 reg)
+{
+       int res;
+
+       /* What size location is it? */
+       switch( reg ) {
+       case LM85_REG_FAN(0) :  /* Read WORD data */
+       case LM85_REG_FAN(1) :
+       case LM85_REG_FAN(2) :
+       case LM85_REG_FAN(3) :
+       case LM85_REG_FAN_MIN(0) :
+       case LM85_REG_FAN_MIN(1) :
+       case LM85_REG_FAN_MIN(2) :
+       case LM85_REG_FAN_MIN(3) :
+       case LM85_REG_ALARM :  /* Read ALARM1 and ALARM2 */
+       case ADM1027_REG_INTMASK :  /* Read MASK1 and MASK2 */
+       case ADM1027_REG_EXTEND_ADC :  /* Read ADC1 and ADC2 */
+               reg &= 0xff ;  /* Pseudo words have address + 0x0100 */
+               res = i2c_smbus_read_byte_data(client, reg) & 0xff ;
+               res |= (i2c_smbus_read_byte_data(client, reg+1) & 0xff) << 8 ;
+               break ;
+       case ADT7463_REG_TMIN_CTL :  /* Read WORD MSB, LSB */
+               reg &= 0xff ;  /* Pseudo words have address + 0x0100 */
+               res = (i2c_smbus_read_byte_data(client, reg) & 0xff) << 8 ;
+               res |= i2c_smbus_read_byte_data(client, reg+1) & 0xff ;
+               break ;
+       default:        /* Read BYTE data */
+               res = i2c_smbus_read_byte_data(client, reg & 0xff) & 0xff ;
+               break ;
+       }
+
+       return res ;
+}
+
+int lm85_write_value(struct i2c_client *client, u16 reg, int value)
+{
+       int res ;
+
+       switch( reg ) {
+       case LM85_REG_FAN(0) :  /* Write WORD data */
+       case LM85_REG_FAN(1) :
+       case LM85_REG_FAN(2) :
+       case LM85_REG_FAN(3) :
+       case LM85_REG_FAN_MIN(0) :
+       case LM85_REG_FAN_MIN(1) :
+       case LM85_REG_FAN_MIN(2) :
+       case LM85_REG_FAN_MIN(3) :
+       case ADM1027_REG_INTMASK :
+       /* NOTE: ALARM and ADC are read only, so not included here */
+               reg &= 0xff ;  /* Pseudo words have address + 0x0100 */
+               res = i2c_smbus_write_byte_data(client, reg, value & 0xff) ;
+               res |= i2c_smbus_write_byte_data(client, reg+1, (value>>8) & 0xff) ;
+               break ;
+       case ADT7463_REG_TMIN_CTL :  /* Write WORD MSB, LSB */
+               reg &= 0xff ;  /* Pseudo words have address + 0x0100 */
+               res = i2c_smbus_write_byte_data(client, reg, (value>>8) & 0xff);
+               res |= i2c_smbus_write_byte_data(client, reg+1, value & 0xff) ;
+               break ;
+       default:        /* Write BYTE data */
+               res = i2c_smbus_write_byte_data(client, reg & 0xff, value);
+               break ;
+       }
+
+       return res ;
+}
+
+/* Called when we have found a new LM85. It should set limits, etc. */
+void lm85_init_client(struct i2c_client *client)
+{
+       int value;
+       struct lm85_data *data = client->data;
+
+#ifdef DEBUG
+       printk("lm85(%d): Initializing device\n", client->id);
+#endif
+
+       /* Warn if part was not "READY" */
+       value = lm85_read_value(client, LM85_REG_CONFIG);
+#ifdef DEBUG
+       printk("lm85(%d): LM85_REG_CONFIG is: 0x%02x\n", client->id, value );
+#endif
+       if( value & 0x02 ) {
+               printk("lm85(%d): Client (%d,0x%02x) config is locked.\n",
+                           client->id,
+                           i2c_adapter_id(client->adapter), client->addr );
+       };
+       if( ! (value & 0x04) ) {
+               printk("lm85(%d): Client (%d,0x%02x) is not ready.\n",
+                           client->id,
+                           i2c_adapter_id(client->adapter), client->addr );
+       };
+       if( (data->type == adm1027 || data->type == adt7463)
+           && (value & 0x10)
+       ) {
+               printk("lm85(%d): Client (%d,0x%02x) VxI mode is set.  "
+                       "Please report this to the lm85 maintainer.\n",
+                           client->id,
+                           i2c_adapter_id(client->adapter), client->addr );
+       };
+
+       /* See if SYNC to PWM3 is set */
+       if( data->type == adt7463 
+           && (lm85_read_value(client, LM85_REG_AFAN_SPIKE1) & 0x10)
+       ) {
+               printk("lm85(%d): Sync to PWM3 is set.  Expect PWM3 "
+                       "to control fans 2, 3, and 4\n",
+                       client->id );
+       };
+
+       /* See if PWM2 is #SMBALERT */
+       if( (data->type == adm1027 || data->type == adt7463)
+           && (lm85_read_value(client, ADM1027_REG_CONFIG3) & 0x01)
+       ) {
+               printk("lm85(%d): PWM2 is SMBALERT.  PWM2 not available.\n",
+                       client->id );
+       };
+
+       /* Check if 2.5V and 5V inputs are reconfigured */
+       if( data->type == adt7463 ) {
+               value = lm85_read_value(client, ADT7463_REG_CONFIG4);
+               if( value & 0x01 ) {
+                       printk("lm85(%d): 2.5V input (in0) is SMBALERT.  "
+                               "in0 not available.\n", client->id );
+               };
+               if( value & 0x02 ) {
+                       printk("lm85(%d): 5V input (in3) is THERM.  "
+                               "in3 not available.\n", client->id );
+               }
+       };
+
+       /* FIXME?  Display EMC6D100 config info? */
+
+       /* WE INTENTIONALLY make no changes to the limits,
+        *   offsets, pwms, fans and zones.  If they were
+        *   configured, we don't want to mess with them.
+        *   If they weren't, the default is 100% PWM, no
+        *   control and will suffice until 'sensors -s'
+        *   can be run by the user.
+        */
+
+       /* Start monitoring */
+       value = lm85_read_value(client, LM85_REG_CONFIG);
+       /* Try to clear LOCK, Set START, save everything else */
+       value = ((value & ~ 0x02) | 0x01) & 0xff ;
+#ifdef DEBUG
+       printk("lm85(%d): Setting CONFIG to: 0x%02x\n", client->id, value );
+#endif
+       lm85_write_value(client, LM85_REG_CONFIG, value);
+
+}
+
+void lm85_update_client(struct i2c_client *client)
+{
+       struct lm85_data *data = client->data;
+       int i;
+
+       down(&data->update_lock);
+
+       if (!data->valid
+           || (jiffies - data->last_reading > LM85_DATA_INTERVAL )) {
+               /* Things that change quickly */
+
+#ifdef DEBUG
+               printk("lm85(%d): Reading sensor values\n", client->id);
+#endif
+               /* Have to read extended bits first to "freeze" the
+                * more significant bits that are read later.
+                */
+               switch( data->type ) {
+               case adm1027 :
+               case adt7463 :
+                       data->extend_adc =
+                           lm85_read_value(client, ADM1027_REG_EXTEND_ADC);
+                       break ;
+               default :
+                       data->extend_adc = 0 ;
+                       break ;
+               }
+
+               for (i = 0; i <= 4; ++i) {
+                       data->in[i] =
+                           lm85_read_value(client, LM85_REG_IN(i));
+               }
+
+               for (i = 0; i <= 3; ++i) {
+                       data->fan[i] =
+                           lm85_read_value(client, LM85_REG_FAN(i));
+               }
+
+               for (i = 0; i <= 2; ++i) {
+                       data->temp[i] =
+                           lm85_read_value(client, LM85_REG_TEMP(i));
+               }
+
+               for (i = 0; i <= 2; ++i) {
+                       data->pwm[i] =
+                           lm85_read_value(client, LM85_REG_PWM(i));
+               }
+
+               data->alarms = lm85_read_value(client, LM85_REG_ALARM);
+
+               switch( ((struct lm85_data *)(client->data))->type ) {
+               case adt7463 :
+                       /* REG_THERM code duplicated in therm_signal() */
+                       i = lm85_read_value(client, ADT7463_REG_THERM);
+                       if( data->therm_total < LONG_MAX - 256 ) {
+                           data->therm_total += i ;
+                       }
+                       if( i >= 255 ) {
+                               ++data->therm_ovfl ;
+                       }
+                       break ;
+               case emc6d100 :
+                       /* Three more voltage sensors */
+                       for (i = 5; i <= 7; ++i) {
+                           data->in[i] =
+                               lm85_read_value(client, EMC6D100_REG_IN(i));
+                       }
+                       /* More alarm bits */
+                       data->alarms |=
+                           lm85_read_value(client, EMC6D100_REG_ALARM3) << 16;
+
+                       break ;
+               default : break ; /* no warnings */
+               }
+
+               data->last_reading = jiffies ;
+       };  /* last_reading */
+
+       if (!data->valid
+           || (jiffies - data->last_config > LM85_CONFIG_INTERVAL) ) {
+               /* Things that don't change often */
+
+#ifdef DEBUG
+               printk("lm85(%d): Reading config values\n", client->id);
+#endif
+               for (i = 0; i <= 4; ++i) {
+                       data->in_min[i] =
+                           lm85_read_value(client, LM85_REG_IN_MIN(i));
+                       data->in_max[i] =
+                           lm85_read_value(client, LM85_REG_IN_MAX(i));
+               }
+
+               for (i = 0; i <= 3; ++i) {
+                       data->fan_min[i] =
+                           lm85_read_value(client, LM85_REG_FAN_MIN(i));
+               }
+
+               for (i = 0; i <= 2; ++i) {
+                       data->temp_min[i] =
+                           lm85_read_value(client, LM85_REG_TEMP_MIN(i));
+                       data->temp_max[i] =
+                           lm85_read_value(client, LM85_REG_TEMP_MAX(i));
+               }
+
+               data->vid = lm85_read_value(client, LM85_REG_VID);
+
+               for (i = 0; i <= 2; ++i) {
+                       int val ;
+                       data->autofan[i].config =
+                           lm85_read_value(client, LM85_REG_AFAN_CONFIG(i));
+                       val = lm85_read_value(client, LM85_REG_AFAN_RANGE(i));
+                       data->autofan[i].freq = val & 0x07 ;
+                       data->zone[i].range = (val >> 4) & 0x0f ;
+                       data->autofan[i].min_pwm =
+                           lm85_read_value(client, LM85_REG_AFAN_MINPWM(i));
+                       data->zone[i].limit =
+                           lm85_read_value(client, LM85_REG_AFAN_LIMIT(i));
+                       data->zone[i].critical =
+                           lm85_read_value(client, LM85_REG_AFAN_CRITICAL(i));
+               }
+
+               i = lm85_read_value(client, LM85_REG_AFAN_SPIKE1);
+               data->smooth[0] = i & 0x0f ;
+               data->syncpwm3 = i & 0x10 ;  /* Save PWM3 config */
+               data->autofan[0].min_off = i & 0x20 ;
+               data->autofan[1].min_off = i & 0x40 ;
+               data->autofan[2].min_off = i & 0x80 ;
+               i = lm85_read_value(client, LM85_REG_AFAN_SPIKE2);
+               data->smooth[1] = (i>>4) & 0x0f ;
+               data->smooth[2] = i & 0x0f ;
+
+               i = lm85_read_value(client, LM85_REG_AFAN_HYST1);
+               data->zone[0].hyst = (i>>4) & 0x0f ;
+               data->zone[1].hyst = i & 0x0f ;
+
+               i = lm85_read_value(client, LM85_REG_AFAN_HYST2);
+               data->zone[2].hyst = (i>>4) & 0x0f ;
+
+               switch( ((struct lm85_data *)(client->data))->type ) {
+               case lm85b :
+               case lm85c :
+                       data->tach_mode = lm85_read_value(client,
+                               LM85_REG_TACH_MODE );
+                       data->spinup_ctl = lm85_read_value(client,
+                               LM85_REG_SPINUP_CTL );
+                       break ;
+               case adt7463 :
+                       for (i = 0; i <= 2; ++i) {
+                           data->oppoint[i] = lm85_read_value(client,
+                               ADT7463_REG_OPPOINT(i) );
+                       }
+                       data->tmin_ctl = lm85_read_value(client,
+                               ADT7463_REG_TMIN_CTL );
+                       data->therm_limit = lm85_read_value(client,
+                               ADT7463_REG_THERM_LIMIT );
+               /* FALL THROUGH */
+               case adm1027 :
+                       for (i = 0; i <= 2; ++i) {
+                           data->temp_offset[i] = lm85_read_value(client,
+                               ADM1027_REG_TEMP_OFFSET(i) );
+                       }
+                       data->tach_mode = lm85_read_value(client,
+                               ADM1027_REG_CONFIG3 );
+                       data->fan_ppr = lm85_read_value(client,
+                               ADM1027_REG_FAN_PPR );
+                       data->alarm_mask = lm85_read_value(client,
+                               ADM1027_REG_INTMASK );
+                       break ;
+               case emc6d100 :
+                       for (i = 5; i <= 7; ++i) {
+                           data->in_min[i] =
+                               lm85_read_value(client, EMC6D100_REG_IN_MIN(i));
+                           data->in_max[i] =
+                               lm85_read_value(client, EMC6D100_REG_IN_MAX(i));
+                       }
+                       break ;
+               default : break ; /* no warnings */
+               }
+       
+               data->last_config = jiffies;
+       };  /* last_config */
+
+       data->valid = 1;
+
+       up(&data->update_lock);
+}
+
+
+/* The next functions are the call-back functions of the /proc/sys and
+   sysctl files. Which function is used is defined in the ctl_table in
+   the extra1 field.
+   Each function must return the magnitude (power of 10 to divide the data
+   with) if it is called with operation==SENSORS_PROC_REAL_INFO.  It must
+   put a maximum of *nrels elements in results reflecting the data of this
+   file, and set *nrels to the number it actually put in it, if operation==
+   SENSORS_PROC_REAL_READ.  Finally, it must get upto *nrels elements from
+   results and write them to the chip, if operations==SENSORS_PROC_REAL_WRITE.
+ */
+void lm85_in(struct i2c_client *client, int operation, int ctl_name,
+            int *nrels_mag, long *results)
+{
+       struct lm85_data *data = client->data;
+       int nr = ctl_name - LM85_SYSCTL_IN0;
+
+       if (nr < 0 || nr > 4)
+               return ;  /* ERROR */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 3;  /* 1.000 */
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               int  ext = 0 ;
+               lm85_update_client(client);
+               ext = EXT_FROM_REG(data->extend_adc, nr);
+               results[0] = INS_FROM_REG(nr,data->in_min[nr]);
+               results[1] = INS_FROM_REG(nr,data->in_max[nr]);
+               results[2] = INSEXT_FROM_REG(nr,data->in[nr],ext);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               down(&data->update_lock);
+               if (*nrels_mag > 1) {
+                       data->in_max[nr] = INS_TO_REG(nr,results[1]);
+                       lm85_write_value(client, LM85_REG_IN_MAX(nr),
+                                        data->in_max[nr]);
+               }
+               if (*nrels_mag > 0) {
+                       data->in_min[nr] = INS_TO_REG(nr,results[0]);
+                       lm85_write_value(client, LM85_REG_IN_MIN(nr),
+                                        data->in_min[nr]);
+               }
+               up(&data->update_lock);
+       }
+}
+
+void lm85_fan(struct i2c_client *client, int operation, int ctl_name,
+             int *nrels_mag, long *results)
+{
+       struct lm85_data *data = client->data;
+       int nr = ctl_name - LM85_SYSCTL_FAN1 ;
+
+       if (nr < 0 || nr > 3)
+               return ;  /* ERROR */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               lm85_update_client(client);
+               results[0] = FAN_FROM_REG(data->fan_min[nr]);
+               results[1] = FAN_FROM_REG(data->fan[nr]);
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               down(&data->update_lock);
+               if (*nrels_mag > 0) {
+                       data->fan_min[nr] = FAN_TO_REG(results[0]);
+                       lm85_write_value(client, LM85_REG_FAN_MIN(nr),
+                                        data->fan_min[nr]);
+               }
+               up(&data->update_lock);
+       }
+}
+
+
+void lm85_temp(struct i2c_client *client, int operation, int ctl_name,
+              int *nrels_mag, long *results)
+{
+       struct lm85_data *data = client->data;
+       int nr = ctl_name - LM85_SYSCTL_TEMP1 ;
+
+       if (nr < 0 || nr > 2)
+               return ;  /* ERROR */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 2;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               int  ext = 0 ;
+               lm85_update_client(client);
+
+               /* +5 for offset of temp data in ext reg */
+               ext = EXT_FROM_REG(data->extend_adc, nr+5);
+
+               results[0] = TEMP_FROM_REG(data->temp_min[nr]);
+               results[1] = TEMP_FROM_REG(data->temp_max[nr]);
+               results[2] = TEMPEXT_FROM_REG(data->temp[nr],ext);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               down(&data->update_lock);
+               if (*nrels_mag > 1) {
+                       data->temp_max[nr] = TEMP_TO_REG(results[1]);
+                       lm85_write_value(client, LM85_REG_TEMP_MAX(nr),
+                                        data->temp_max[nr]);
+               }
+               if (*nrels_mag > 0) {
+                       data->temp_min[nr] = TEMP_TO_REG(results[0]);
+                       lm85_write_value(client, LM85_REG_TEMP_MIN(nr),
+                                        data->temp_min[nr]);
+               }
+               up(&data->update_lock);
+       }
+}
+
+void lm85_pwm(struct i2c_client *client, int operation, int ctl_name,
+             int *nrels_mag, long *results)
+{
+       struct lm85_data *data = client->data;
+       int nr = ctl_name - LM85_SYSCTL_PWM1 ;
+       int pwm_zone ;
+
+       if (nr < 0 || nr > 2)
+               return ;  /* ERROR */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               lm85_update_client(client);
+               results[0] = PWM_FROM_REG(data->pwm[nr]);
+               pwm_zone = ZONE_FROM_REG(data->autofan[nr].config);
+               /* PWM "enabled" if not off (0) nor on (-1) */
+               results[1] = pwm_zone != 0 && pwm_zone != -1 ;
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               down(&data->update_lock);
+               /* PWM enable is read-only */
+               if (*nrels_mag > 0) {
+                       data->pwm[nr] = PWM_TO_REG(results[0]);
+                       lm85_write_value(client, LM85_REG_PWM(nr),
+                                        data->pwm[nr]);
+               }
+               up(&data->update_lock);
+       }
+}
+
+void lm85_vid(struct i2c_client *client, int operation, int ctl_name,
+             int *nrels_mag, long *results)
+{
+       struct lm85_data *data = client->data;
+
+       if( ctl_name != LM85_SYSCTL_VID )
+               return ;  /* ERROR */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 3;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               lm85_update_client(client);
+               results[0] = VID_FROM_REG((data->vid)&0x3f,data->vrm);
+               *nrels_mag = 1;
+       }
+}
+
+void lm85_vrm(struct i2c_client *client, int operation, int ctl_name,
+             int *nrels_mag, long *results)
+{
+       struct lm85_data *data = client->data;
+
+       if( ctl_name != LM85_SYSCTL_VRM )
+               return ;  /* ERROR */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               results[0] = data->vrm ;
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               down(&data->update_lock);
+               if (*nrels_mag > 0) {
+                       data->vrm = results[0] ;
+               }
+               up(&data->update_lock);
+       }
+}
+
+void lm85_alarms(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       struct lm85_data *data = client->data;
+
+       if( ctl_name != LM85_SYSCTL_ALARMS )
+               return ;  /* ERROR */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               lm85_update_client(client);
+               results[0] = ALARMS_FROM_REG(data->alarms);
+               *nrels_mag = 1;
+       }
+}
+
+void lm85_spinup_ctl(struct i2c_client *client, int operation, int ctl_name,
+                 int *nrels_mag, long *results)
+{
+       struct lm85_data *data = client->data;
+       int old;
+
+       if( ctl_name != LM85_SYSCTL_SPINUP_CTL )
+               return ;  /* ERROR */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               lm85_update_client(client);
+               results[0] = (data->spinup_ctl & 1) != 0 ;
+               results[1] = (data->spinup_ctl & 2) != 0 ;
+               results[2] = (data->spinup_ctl & 4) != 0 ;
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               down(&data->update_lock);
+               old = data->spinup_ctl ;
+               if (*nrels_mag > 2) {
+                       old = (old & (~4)) | (results[2]?4:0) ;
+               }
+               if (*nrels_mag > 1) {
+                       old = (old & (~2)) | (results[1]?2:0) ;
+               }
+               if (*nrels_mag > 0) {
+                       old = (old & (~1)) | (results[0]?1:0) ;
+                       lm85_write_value(client, LM85_REG_SPINUP_CTL, old);
+                       data->spinup_ctl = old ;
+               }
+               up(&data->update_lock);
+       }
+}
+
+void lm85_tach_mode(struct i2c_client *client, int operation, int ctl_name,
+                 int *nrels_mag, long *results)
+{
+       struct lm85_data *data = client->data;
+       int old;
+
+       /* Tach Mode 1, Tach Mode 2, Tach Mode 3 & 4 */
+
+       if( ctl_name != LM85_SYSCTL_TACH_MODE )
+               return ;  /* ERROR */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               lm85_update_client(client);
+               results[0] = (data->tach_mode & 0x03) ;
+               results[1] = (data->tach_mode & 0x0c) >> 2 ;
+               results[2] = (data->tach_mode & 0x30) >> 4 ;
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               down(&data->update_lock);
+               old = data->tach_mode ;
+               if (*nrels_mag > 2) {
+                       old = (old & (~0x30)) | ((results[2]&3) << 4) ;
+               }
+               if (*nrels_mag > 1) {
+                       old = (old & (~0x0c)) | ((results[1]&3) << 2) ;
+               }
+               if (*nrels_mag > 0) {
+                       old = (old & (~0x03)) |  (results[0]&3) ;
+                       lm85_write_value(client, LM85_REG_TACH_MODE, old);
+                       data->tach_mode = old ;
+               }
+               up(&data->update_lock);
+       }
+}
+
+void adm1027_tach_mode(struct i2c_client *client, int operation, int ctl_name,
+                 int *nrels_mag, long *results)
+{
+       struct lm85_data *data = client->data;
+       int old;
+
+       /* Tach/DC 1, Tach/DC 2, Tach/DC 3, Tach/DC 4 */
+
+       if( ctl_name != ADM1027_SYSCTL_TACH_MODE )
+               return ;  /* ERROR */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               lm85_update_client(client);
+               results[0] = (data->tach_mode & 0x10) != 0 ;
+               results[1] = (data->tach_mode & 0x20) != 0 ;
+               results[2] = (data->tach_mode & 0x40) != 0 ;
+               results[3] = (data->tach_mode & 0x80) != 0 ;
+               *nrels_mag = 4;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               down(&data->update_lock);
+               old = data->tach_mode ;
+               if (*nrels_mag > 3) {
+                       old = (old & (~0x80)) | (results[3] ? 0x80 : 0) ;
+               }
+               if (*nrels_mag > 2) {
+                       old = (old & (~0x40)) | (results[2] ? 0x40 : 0) ;
+               }
+               if (*nrels_mag > 1) {
+                       old = (old & (~0x20)) | (results[1] ? 0x20 : 0) ;
+               }
+               if (*nrels_mag > 0) {
+                       old = (old & (~0x10)) | (results[0] ? 0x10 : 0) ;
+
+                       /* Enable fast measurements if any TACH's are DC */
+                       old = (old & (~0x08)) | ((old&0xf0) ? 0x08 : 0) ;
+
+                       lm85_write_value(client, ADM1027_REG_CONFIG3, old);
+                       data->tach_mode = old ;
+               }
+               up(&data->update_lock);
+       }
+}
+
+void lm85_pwm_config(struct i2c_client *client, int operation, int ctl_name,
+                 int *nrels_mag, long *results)
+{
+       struct lm85_data *data = client->data;
+       int nr = ctl_name - LM85_SYSCTL_PWM_CFG1 ;
+
+       /* Spinup, min PWM, PWM Frequency, min below limit, Invert */
+
+       if (nr < 0 || nr > 2)
+               return ;  /* ERROR */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               lm85_update_client(client);
+
+               results[0] = SPINUP_FROM_REG(data->autofan[nr].config);
+               results[1] = PWM_FROM_REG(data->autofan[nr].min_pwm)*10;
+               results[2] = FREQ_FROM_REG(data->autofan[nr].freq);
+               results[3] = data->autofan[nr].min_off ? 10 : 0 ;
+               results[4] = (data->autofan[nr].config & 0x10) ? 10 : 0 ;
+               *nrels_mag = 5;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               int  old_config ;
+
+               down(&data->update_lock);
+               old_config = data->autofan[nr].config ;
+               if (*nrels_mag > 4) {
+                       old_config = (old_config & (~0x10)) | (results[4]?0x10:0) ;
+               }
+               if (*nrels_mag > 3) {
+                       data->autofan[nr].min_off = results[3] != 0 ;
+                       lm85_write_value(client, LM85_REG_AFAN_SPIKE1,
+                               data->smooth[0]
+                               | data->syncpwm3
+                               | (data->autofan[0].min_off ? 0x20 : 0)
+                               | (data->autofan[1].min_off ? 0x40 : 0)
+                               | (data->autofan[2].min_off ? 0x80 : 0)
+                       );
+               }
+               if (*nrels_mag > 2) {
+                       data->autofan[nr].freq = FREQ_TO_REG(results[2]) ;
+                       lm85_write_value(client, LM85_REG_AFAN_RANGE(nr),
+                           (data->zone[nr].range << 4)
+                           | data->autofan[nr].freq
+                       );
+               }
+               if (*nrels_mag > 1) {
+                       data->autofan[nr].min_pwm = PWM_TO_REG((results[1]+5)/10);
+                       lm85_write_value(client, LM85_REG_AFAN_MINPWM(nr),
+                                       data->autofan[nr].min_pwm
+                       );
+               }
+               if (*nrels_mag > 0) {
+                       old_config = (old_config & (~0x07)) | SPINUP_TO_REG(results[0]) ;
+                       lm85_write_value(client, LM85_REG_AFAN_CONFIG(nr), old_config);
+                       data->autofan[nr].config = old_config ;
+               }
+               up(&data->update_lock);
+       }
+}
+
+void lm85_smooth(struct i2c_client *client, int operation, int ctl_name,
+                 int *nrels_mag, long *results)
+{
+       struct lm85_data *data = client->data;
+       int nr = ctl_name - LM85_SYSCTL_SMOOTH1 ;
+
+       if (nr < 0 || nr > 2)
+               return ;  /* ERROR */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               lm85_update_client(client);
+               results[0] = SMOOTH_FROM_REG(data->smooth[nr]);
+               *nrels_mag = 1;
+
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               down(&data->update_lock);
+               if( *nrels_mag > 0 ) {
+                       data->smooth[nr] = SMOOTH_TO_REG(results[0]);
+               }
+               if( nr == 0 ) {
+                   lm85_write_value(client, LM85_REG_AFAN_SPIKE1,
+                       data->smooth[0]
+                       | data->syncpwm3
+                       | (data->autofan[0].min_off ? 0x20 : 0)
+                       | (data->autofan[1].min_off ? 0x40 : 0)
+                       | (data->autofan[2].min_off ? 0x80 : 0)
+                   );
+               } else {
+                   lm85_write_value(client, LM85_REG_AFAN_SPIKE2,
+                       (data->smooth[1] << 4) | data->smooth[2]);
+               }
+               up(&data->update_lock);
+       }
+}
+
+void lm85_zone(struct i2c_client *client, int operation, int ctl_name,
+                 int *nrels_mag, long *results)
+{
+       struct lm85_data *data = client->data;
+       int nr = ctl_name - LM85_SYSCTL_ZONE1 ;
+
+       /* Limit, Hysteresis (neg), Range, Critical */
+
+       if (nr < 0 || nr > 2)
+               return ;  /* ERROR */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               lm85_update_client(client);
+
+               results[0] = TEMP_FROM_REG(data->zone[nr].limit) / 10;
+               results[1] = HYST_FROM_REG(data->zone[nr].hyst);
+               results[2] = RANGE_FROM_REG(data->zone[nr].range);
+               results[3] = TEMP_FROM_REG(data->zone[nr].critical) / 10;
+               *nrels_mag = 4;
+
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               down(&data->update_lock);
+               if (*nrels_mag > 3) {
+                       data->zone[nr].critical = TEMP_TO_REG(results[3]*10);
+                       lm85_write_value(client, LM85_REG_AFAN_CRITICAL(nr),
+                               data->zone[nr].critical );
+               }
+               if (*nrels_mag > 2) {
+                       data->zone[nr].range = RANGE_TO_REG(results[2]);
+                       lm85_write_value(client, LM85_REG_AFAN_RANGE(nr),
+                           (data->zone[nr].range << 4)
+                           | data->autofan[nr].freq
+                       );
+               }
+               if (*nrels_mag > 1) {
+                       data->zone[nr].hyst = HYST_TO_REG(results[1]);
+                       if( nr == 0 || nr == 1 ) {
+                           lm85_write_value(client, LM85_REG_AFAN_HYST1,
+                               (data->zone[0].hyst << 4)
+                               | data->zone[1].hyst
+                           );
+                       } else {
+                           lm85_write_value(client, LM85_REG_AFAN_HYST2,
+                               (data->zone[2].hyst << 4)
+                           );
+                       }
+               }
+               if (*nrels_mag > 0) {
+                       data->zone[nr].limit = TEMP_TO_REG(results[0]*10);
+                       lm85_write_value(client, LM85_REG_AFAN_LIMIT(nr),
+                           data->zone[nr].limit
+                       );
+               }
+               up(&data->update_lock);
+       }
+}
+
+void lm85_pwm_zone(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       struct lm85_data *data = client->data;
+       int nr = ctl_name - LM85_SYSCTL_PWM_ZONE1 ;
+
+       if (nr < 0 || nr > 2)
+               return ;  /* ERROR */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               lm85_update_client(client);
+               results[0] = ZONE_FROM_REG(data->autofan[nr].config);
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               down(&data->update_lock);
+               if (*nrels_mag > 0) {
+                       data->autofan[nr].config =
+                           (data->autofan[nr].config & (~0xe0))
+                           | ZONE_TO_REG(results[0]) ;
+                       lm85_write_value(client, LM85_REG_AFAN_CONFIG(nr),
+                           data->autofan[nr].config);
+               }
+               up(&data->update_lock);
+       }
+}
+
+void adm1027_temp_offset(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       struct lm85_data *data = client->data;
+       int nr = ctl_name - ADM1027_SYSCTL_TEMP_OFFSET1 ;
+
+       if (nr < 0 || nr > 2)
+               return ;  /* ERROR */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 2;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               lm85_update_client(client);
+               switch( data->type ) {
+               case adm1027 :
+               default :
+                       results[0] = TEMP_FROM_REG(data->temp_offset[nr]);
+                       break ;
+               case adt7463 :
+                       results[0] = TEMPEXT_FROM_REG(0,data->temp_offset[nr]);
+                       break ;
+               }
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               down(&data->update_lock);
+               if (*nrels_mag > 0) {
+                       switch( data->type ) {
+                       case adm1027 :
+                       default :
+                           data->temp_offset[nr] = TEMP_TO_REG(results[0]);
+                           break ;
+                       case adt7463 :
+                           data->temp_offset[nr] = EXTTEMP_TO_REG(results[0]);
+                           break ;
+                       };
+                       lm85_write_value(client, ADM1027_REG_TEMP_OFFSET(nr),
+                           data->temp_offset[nr]);
+               }
+               up(&data->update_lock);
+       }
+}
+
+void adm1027_fan_ppr(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       struct lm85_data *data = client->data;
+       int old ;
+
+       if (ctl_name != ADM1027_SYSCTL_FAN_PPR)
+               return ;  /* ERROR */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               lm85_update_client(client);
+               results[0] = PPR_FROM_REG(data->fan_ppr,0);
+               results[1] = PPR_FROM_REG(data->fan_ppr,1);
+               results[2] = PPR_FROM_REG(data->fan_ppr,2);
+               results[3] = PPR_FROM_REG(data->fan_ppr,3);
+               *nrels_mag = 4;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               down(&data->update_lock);
+               old = data->fan_ppr ;
+               if (*nrels_mag > 3) {
+                       old = (old & ~PPR_MASK(3)) | PPR_TO_REG(results[3],3);
+               };
+               if (*nrels_mag > 2) {
+                       old = (old & ~PPR_MASK(2)) | PPR_TO_REG(results[2],2);
+               };
+               if (*nrels_mag > 1) {
+                       old = (old & ~PPR_MASK(1)) | PPR_TO_REG(results[1],1);
+               };
+               if (*nrels_mag > 0) {
+                       old = (old & ~PPR_MASK(0)) | PPR_TO_REG(results[0],0);
+                       lm85_write_value(client, ADM1027_REG_FAN_PPR, old);
+                       data->fan_ppr = old ;
+               }
+               up(&data->update_lock);
+       }
+}
+
+void adm1027_alarm_mask(struct i2c_client *client, int operation,
+               int ctl_name, int *nrels_mag, long *results)
+{
+       struct lm85_data *data = client->data;
+
+       if( ctl_name != ADM1027_SYSCTL_ALARM_MASK )
+               return ;  /* ERROR */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               lm85_update_client(client);
+               results[0] = INTMASK_FROM_REG(data->alarm_mask);
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               down(&data->update_lock);
+               if (*nrels_mag > 0) {
+                       data->alarm_mask = INTMASK_TO_REG(results[0]);
+                       lm85_write_value(client, ADM1027_REG_INTMASK,
+                           data->alarm_mask);
+               }
+               up(&data->update_lock);
+       }
+}
+
+void adt7463_tmin_ctl(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       struct lm85_data *data = client->data;
+       int nr = ctl_name - ADT7463_SYSCTL_TMIN_CTL1 ;
+       u16 old ;
+
+       if (nr < 0 || nr > 2)
+               return ;  /* ERROR */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               old = data->tmin_ctl ;
+               results[0] = (old & ( 0x2000 << nr )) != 0 ;
+               results[1] = (old >> (nr*3)) & 0x07  ;
+               results[2] = (old & ( 0x0400 << nr )) != 0 ;
+               results[3] = OPPOINT_FROM_REG(data->oppoint[nr]);
+               *nrels_mag = 4;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               down(&data->update_lock);
+               old = data->tmin_ctl ;
+               if (*nrels_mag > 3) {
+                       data->oppoint[nr] = OPPOINT_TO_REG(results[3]);
+                       lm85_write_value(client, ADT7463_REG_OPPOINT(nr),
+                           data->oppoint[nr]);
+               };
+               if (*nrels_mag > 2) {
+                       if( results[2] ) {
+                               old |= (0x0400 << nr) ;
+                       } else {
+                               old &= ~(0x0400 << nr) ;
+                       }
+               };
+               if (*nrels_mag > 1) {
+                       old &= ~(0x07 << (nr*3)) ;
+                       old |= (results[1] & 0x07) << (nr*3) ;
+               };
+               if (*nrels_mag > 0) {
+                       if( results[0] ) {
+                               old |= 0x2000 << nr ;
+                       } else {
+                               old &= ~(0x2000 << nr) ;
+                       }
+                       lm85_write_value(client, ADT7463_REG_TMIN_CTL, old);
+                       data->tmin_ctl = old ;
+               }
+               up(&data->update_lock);
+       }
+}
+
+void adt7463_therm_signal(struct i2c_client *client, int operation,
+               int ctl_name, int *nrels_mag, long *results)
+{
+       struct lm85_data *data = client->data;
+       int counts ;
+
+       if (ctl_name != ADT7463_SYSCTL_THERM_SIGNAL)
+               return ;  /* ERROR */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               /* Don't call update_client here because
+                *   ADT7463_REG_THERM has to be read every
+                *   5 seconds to prevent lost counts
+                */
+               down(&data->update_lock);
+               counts = lm85_read_value(client, ADT7463_REG_THERM) & 0xff;
+               if( data->therm_total < LONG_MAX - 256 ) {
+                   data->therm_total += counts ;
+               }
+               if( counts >= 255 ) {
+                   ++data->therm_ovfl ;
+               }
+               up(&data->update_lock);
+
+               results[0] = data->therm_limit ;
+               results[1] = data->therm_total ;
+               results[2] = data->therm_ovfl ;
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               down(&data->update_lock);
+               /* therm_total and therm_ovfl are read only */
+               if (*nrels_mag > 0) {
+                       data->therm_limit = SENSORS_LIMIT(results[0],0,255);
+                       lm85_write_value(client, ADT7463_REG_THERM_LIMIT,
+                           data->therm_limit);
+               };
+               up(&data->update_lock);
+       }
+}
+
+
+void emc6d100_in(struct i2c_client *client, int operation, int ctl_name,
+            int *nrels_mag, long *results)
+{
+       struct lm85_data *data = client->data;
+       int nr = ctl_name - EMC6D100_SYSCTL_IN5 +5;
+
+       if (nr < 5 || nr > 7)
+               return ;  /* ERROR */
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 3;  /* 1.000 */
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               lm85_update_client(client);
+               results[0] = INS_FROM_REG(nr,data->in_min[nr]);
+               results[1] = INS_FROM_REG(nr,data->in_max[nr]);
+               results[2] = INS_FROM_REG(nr,data->in[nr]);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               down(&data->update_lock);
+               if (*nrels_mag > 1) {
+                       data->in_max[nr] = INS_TO_REG(nr,results[1]);
+                       lm85_write_value(client, EMC6D100_REG_IN_MAX(nr),
+                                        data->in_max[nr]);
+               }
+               if (*nrels_mag > 0) {
+                       data->in_min[nr] = INS_TO_REG(nr,results[0]);
+                       lm85_write_value(client, EMC6D100_REG_IN_MIN(nr),
+                                        data->in_min[nr]);
+               }
+               up(&data->update_lock);
+       }
+}
+
+
+static int __init sm_lm85_init(void)
+{
+       printk("lm85: Version %s (%s)\n", LM_VERSION, LM_DATE);
+       printk("lm85: See http://www.penguincomputing.com/lm_sensors for more info.\n" );
+       return i2c_add_driver(&lm85_driver);
+}
+
+static void __exit sm_lm85_exit(void)
+{
+       i2c_del_driver(&lm85_driver);
+}
+
+/* Thanks to Richard Barrington for adding the LM85 to sensors-detect.
+ * Thanks to Margit Schubert-While <margitsw@t-online.de> for help with
+ *     post 2.7.0 CVS changes
+ */
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Philip Pokorny <ppokorny@penguincomputing.com");
+MODULE_DESCRIPTION("LM85-B, LM85-C driver");
+
+module_init(sm_lm85_init);
+module_exit(sm_lm85_exit);
--- linux-old/drivers/sensors/lm87.c    Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/lm87.c        Mon Dec 13 20:18:49 2004
@@ -0,0 +1,988 @@
+/*
+    LM87.c - Part of lm_sensors, Linux kernel modules for hardware
+             monitoring
+    Copyright (c) 2000  Frodo Looijaard <frodol@dds.nl>
+                        Philip Edelbrock <phil@netroedge.com>
+                       Stephen Rousset <stephen.rousset@rocketlogix.com>
+                       Dan Eaton <dan.eaton@rocketlogix.com>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or 
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+#include <linux/sensors_vid.h>
+
+/* Chip configuration settings.  These should be set to reflect the
+HARDWARE configuration of your chip.  By default (read: when all of
+these are left commented out), this driver assumes that the
+configuration is the same as National's defaults for the Channel Mode
+register.
+
+Set to '1' the appropriate defines, as nessesary:
+
+ - External temp sensors 2 (possible second CPU temp)
+   This will disable the 2.5V and Vccp2 readings.
+   Ironically, National decided that you can read the
+   temperature of a second CPU or it's core voltage,
+   but not both!  Comment out if FAULT is reported.  */
+
+/* #define LM87_EXT2 1 */
+
+/* Aux analog input. When enabled, the Fan 1 reading 
+   will be disabled */
+
+/* #define LM87_AIN1 1 */
+
+/* Aux analog input 2. When enabled, the Fan 2 reading 
+   will be disabled */
+
+/* #define LM87_AIN2 1 */
+
+/* Internal Vcc is 5V instead of 3.3V */
+
+/* #define LM87_5V_VCC 1 */
+
+/* That's the end of the hardware config defines.  I would have made
+   them insmod params, but it would be too much work. ;') */
+
+
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = { SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { 0x2c, 0x2e, SENSORS_I2C_END };
+static unsigned int normal_isa[] = { SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+/* Insmod parameters */
+SENSORS_INSMOD_1(lm87);
+
+/* The following is the calculation for the register offset
+ * for the monitored items minimum and maximum locations.
+ */
+#define LM87_REG_IN_MAX(nr) (0x2b + ((nr) * 2))
+#define LM87_REG_IN_MIN(nr) (0x2c + ((nr) * 2))
+#define LM87_REG_IN(nr) (0x20 + (nr))
+
+/* Initial limits */
+
+/*
+ * LM87 register definition
+ * 
+ */
+
+      /* The LM87 registers */
+#define LM87_INT_TEMP_HI_LIMIT_LOCKABLE  0x13
+#define LM87_EXT_TEMP_HI_LIMIT_LOCKABLE  0x14
+#define LM87_REG_TEST                    0x15
+#define LM87_REG_CHANNEL_MODE            0x16
+#define LM87_REG_INT_TEMP_HI_LIMIT       0x17
+#define LM87_REG_EXT_TEMP_HI_LIMIT       0x18
+#define LM87_REG_ANALOG_OUT              0x19
+
+      /* These are all read-only */
+#define LM87_REG_2_5V_EXT_TEMP_2         0x20
+#define LM87_REG_VCCP1                   0x21
+#define LM87_REG_3_3V                    0x22  
+#define LM87_REG_5V                      0x23
+#define LM87_REG_12V                     0x24
+#define LM87_REG_VCCP2                   0x25
+#define LM87_REG_EXT_TEMP_1              0x26
+#define LM87_REG_INT_TEMP                0x27  /* LM87 temp. */
+#define LM87_REG_FAN1_AIN1               0x28
+#define LM87_REG_FAN2_AIN2               0x29
+
+/* These are read/write */
+#define LM87_REG_AIN1_LOW                0x1A
+#define LM87_REG_AIN2_LOW                0x1B
+#define LM87_REG_2_5V_EXT_TEMP_2_HIGH    0x2B  
+#define LM87_REG_2_5V_EXT_TEMP_2_LOW     0x2C  
+#define LM87_REG_VCCP1_HIGH              0x2D  
+#define LM87_REG_VCCP1_LOW               0x2E  
+#define LM87_REG_3_3V_HIGH               0x2F
+#define LM87_REG_3_3V_LOW                0x30
+#define LM87_REG_5V_HIGH                 0x31
+#define LM87_REG_5V_LOW                  0x32
+#define LM87_REG_12V_HIGH                0x33
+#define LM87_REG_12V_LOW                 0x34
+#define LM87_REG_VCCP2_HIGH              0x35
+#define LM87_REG_VCCP2_LOW               0x36
+#define LM87_REG_EXT_TEMP_1_HIGH         0x37    
+#define LM87_REG_EXT_TEMP_1_LOW          0x38  
+#define LM87_REG_INT_TEMP_HIGH           0x39  
+#define LM87_REG_INT_TEMP_LOW            0x3A  
+#define LM87_REG_FAN1_AIN1_LIMIT         0x3B
+#define LM87_REG_FAN2_AIN2_LIMIT         0x3C
+#define LM87_REG_COMPANY_ID              0x3E 
+#define LM87_REG_DIE_REV                 0x3F
+
+#define LM87_REG_CONFIG                  0x40
+#define LM87_REG_INT1_STAT               0x41
+#define LM87_REG_INT2_STAT               0x42
+#define LM87_REG_INT1_MASK               0x43
+#define LM87_REG_INT2_MASK               0x44
+#define LM87_REG_CHASSIS_CLEAR           0x46
+#define LM87_REG_VID_FAN_DIV             0x47
+#define LM87_REG_VID4                    0x49
+#define LM87_REG_CONFIG_2                0x4A
+#define LM87_REG_INTRPT_STATUS_1_MIRROR  0x4C
+#define LM87_REG_INTRPT_STATUS_2_MIRROR  0x4D
+#define LM87_REG_SMBALERT_NUM_ENABLE     0x80
+
+
+
+/* Conversions. Rounding and limit checking is only done on the TO_REG
+   variants. Note that you should be a bit careful with which arguments
+   these macros are called: arguments may be evaluated more than once.
+   Fixing this is just not worth it. */
+
+#define IN_TO_REG(val,nr) (SENSORS_LIMIT(((val) & 0xff),0,255))
+#define IN_FROM_REG(val,nr) (val)
+
+static inline u8 FAN_TO_REG(long rpm, int div)
+{
+       if (rpm == 0)
+               return 255;
+       rpm = SENSORS_LIMIT(rpm, 1, 1000000);
+       return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1,
+                            254);
+}
+
+#define FAN_FROM_REG(val,div) ((val)==0?-1:\
+                               (val)==255?0:1350000/((div)*(val)))
+
+#define TEMP_FROM_REG(temp)  (temp * 10)
+
+#define TEMP_LIMIT_FROM_REG(val) (((val)>0x80?(val)-0x100:(val))*10)
+
+#define TEMP_LIMIT_TO_REG(val) SENSORS_LIMIT(((val)<0?(((val)-5)/10):\
+                                                      ((val)+5)/10),0,255)
+#if 0
+#define TEMP_FROM_REG(temp) \
+   ((temp)<256?((((temp)&0x1fe) >> 1) * 10)      + ((temp) & 1) * 5:  \
+               ((((temp)&0x1fe) >> 1) -255) * 10 - ((temp) & 1) * 5)  \
+
+#define TEMP_LIMIT_FROM_REG(val) (val)
+
+#define TEMP_LIMIT_TO_REG(val) SENSORS_LIMIT((val),0,255)
+#endif
+
+
+#define ALARMS_FROM_REG(val) (val)
+
+#define DIV_FROM_REG(val) (1 << (val))
+#define DIV_TO_REG(val) ((val)==1?0:((val)==8?3:((val)==4?2:1)))
+
+/* For each registered LM87, we need to keep some data in memory. That
+   data is pointed to by LM87_list[NR]->data. The structure itself is
+   dynamically allocated, at the same time when a new LM87 client is
+   allocated. */
+struct lm87_data {
+       struct i2c_client client;
+       int sysctl_id;
+       enum chips type;
+
+       struct semaphore update_lock;
+       char valid;             /* !=0 if following fields are valid */
+       unsigned long last_updated;     /* In jiffies */
+
+       u8  in[6];              /* Scaled Register value */
+       u8  in_max[6];          /* Scaled Register value */
+       u8  in_min[6];          /* Scaled Register value */
+       u8  ain1;               /* Register value */
+       u8  ain1_min;           /* Register value */
+       u8  ain1_max;           /* Register value */
+       u8  ain2;               /* Register value */
+       u8  ain2_min;           /* Register value */
+       u8  ain2_max;           /* Register value */
+       u8  fan;                /* Register value */
+       u8  fan_min;            /* Register value */
+       u8  fan_div;            /* Register encoding, shifted right */
+       u8  fan2;               /* Register value */
+       u8  fan2_min;           /* Register value */
+       u8  fan2_div;           /* Register encoding, shifted right */
+       int ext2_temp;          /* Temp, shifted right */
+       int ext_temp;           /* Temp, shifted right */
+       int int_temp;           /* Temp, shifted right */
+       u8  ext_temp_max;       /* Register value */
+       u8  ext_temp_min;       /* Register value */
+       u8  ext2_temp_max;      /* Register value */
+       u8  ext2_temp_min;      /* Register value */
+       u8  int_temp_max;       /* Register value */
+       u8  int_temp_min;       /* Register value */
+       u16 alarms;             /* Register encoding, combined */
+       u8  analog_out;         /* Register value */
+       u8  vid;                /* Register value combined */
+       u8  vrm;                /* VRM version * 10 */
+};
+
+static int lm87_attach_adapter(struct i2c_adapter *adapter);
+static int lm87_detect(struct i2c_adapter *adapter, int address,
+                         unsigned short flags, int kind);
+static int lm87_detach_client(struct i2c_client *client);
+
+static int lm87_read_value(struct i2c_client *client, u8 register);
+static int lm87_write_value(struct i2c_client *client, u8 register,
+                              u8 value);
+static void lm87_update_client(struct i2c_client *client);
+static void lm87_init_client(struct i2c_client *client);
+
+
+static void lm87_in(struct i2c_client *client, int operation,
+                      int ctl_name, int *nrels_mag, long *results);
+#if defined (LM87_AIN1) || defined (LM87_AIN2)
+static void lm87_ain(struct i2c_client *client, int operation,
+                      int ctl_name, int *nrels_mag, long *results);
+#endif
+static void lm87_fan(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void lm87_temp(struct i2c_client *client, int operation,
+                        int ctl_name, int *nrels_mag, long *results);
+static void lm87_alarms(struct i2c_client *client, int operation,
+                          int ctl_name, int *nrels_mag, long *results);
+static void lm87_fan_div(struct i2c_client *client, int operation,
+                           int ctl_name, int *nrels_mag, long *results);
+static void lm87_analog_out(struct i2c_client *client, int operation,
+                              int ctl_name, int *nrels_mag,
+                              long *results);
+static void lm87_vid(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void lm87_vrm(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+
+static int lm87_id = 0;
+
+static struct i2c_driver LM87_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "LM87 sensor driver",
+       .id             = I2C_DRIVERID_LM87,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = lm87_attach_adapter,
+       .detach_client  = lm87_detach_client,
+};
+
+/* -- SENSORS SYSCTL START -- */
+#define LM87_SYSCTL_IN0        1000 /* Volts * 100 */
+#define LM87_SYSCTL_IN1        1001
+#define LM87_SYSCTL_IN2        1002
+#define LM87_SYSCTL_IN3        1003
+#define LM87_SYSCTL_IN4        1004
+#define LM87_SYSCTL_IN5        1005
+#define LM87_SYSCTL_AIN1       1006
+#define LM87_SYSCTL_AIN2       1007
+#define LM87_SYSCTL_FAN1       1102
+#define LM87_SYSCTL_FAN2       1103
+#define LM87_SYSCTL_TEMP1  1250 /* Degrees Celcius * 100 */
+#define LM87_SYSCTL_TEMP2   1251 /* Degrees Celcius * 100 */
+#define LM87_SYSCTL_TEMP3   1252 /* Degrees Celcius * 100 */
+#define LM87_SYSCTL_FAN_DIV    2000 /* 1, 2, 4 or 8 */
+#define LM87_SYSCTL_ALARMS     2001 /* bitvector */
+#define LM87_SYSCTL_ANALOG_OUT 2002
+#define LM87_SYSCTL_VID        2003
+#define LM87_SYSCTL_VRM        2004
+
+#define LM87_ALARM_IN0          0x0001
+#define LM87_ALARM_IN1          0x0002
+#define LM87_ALARM_IN2          0x0004
+#define LM87_ALARM_IN3          0x0008
+#define LM87_ALARM_TEMP1        0x0010
+#define LM87_ALARM_TEMP2        0x0020
+#define LM87_ALARM_TEMP3        0x0020 /* same?? */
+#define LM87_ALARM_FAN1         0x0040
+#define LM87_ALARM_FAN2         0x0080
+#define LM87_ALARM_IN4          0x0100
+#define LM87_ALARM_IN5          0x0200
+#define LM87_ALARM_RESERVED1    0x0400
+#define LM87_ALARM_RESERVED2    0x0800
+#define LM87_ALARM_CHAS         0x1000
+#define LM87_ALARM_THERM_SIG    0x2000
+#define LM87_ALARM_TEMP2_FAULT  0x4000
+#define LM87_ALARM_TEMP3_FAULT 0x08000
+
+/* -- SENSORS SYSCTL END -- */
+
+/* The /proc/sys entries */
+/* These files are created for each detected LM87. This is just a template;
+   though at first sight, you might think we could use a statically
+   allocated list, we need some way to get back to the parent - which
+   is done through one of the 'extra' fields which are initialized 
+   when a new copy is allocated. */
+
+static ctl_table LM87_dir_table_template[] = {
+#ifdef LM87_AIN1
+       {LM87_SYSCTL_AIN1, "in6", NULL, 0, 0644, NULL, &i2c_proc_real,
+         &i2c_sysctl_real, NULL, &lm87_ain},
+#endif
+#ifdef LM87_AIN2
+       {LM87_SYSCTL_AIN2, "in7", NULL, 0, 0644, NULL, &i2c_proc_real,
+         &i2c_sysctl_real, NULL, &lm87_ain},
+#endif
+#ifndef LM87_EXT2
+       {LM87_SYSCTL_IN0, "in0", NULL, 0, 0644, NULL, &i2c_proc_real,
+         &i2c_sysctl_real, NULL, &lm87_in},
+       {LM87_SYSCTL_IN5, "in5", NULL, 0, 0644, NULL, &i2c_proc_real,
+         &i2c_sysctl_real, NULL, &lm87_in},
+#endif
+       {LM87_SYSCTL_IN1, "in1", NULL, 0, 0644, NULL, &i2c_proc_real,
+         &i2c_sysctl_real, NULL, &lm87_in},
+       {LM87_SYSCTL_IN2, "in2", NULL, 0, 0644, NULL, &i2c_proc_real,
+         &i2c_sysctl_real, NULL, &lm87_in},
+       {LM87_SYSCTL_IN3, "in3", NULL, 0, 0644, NULL, &i2c_proc_real,
+         &i2c_sysctl_real, NULL, &lm87_in},
+       {LM87_SYSCTL_IN4, "in4", NULL, 0, 0644, NULL, &i2c_proc_real,
+         &i2c_sysctl_real, NULL, &lm87_in},
+#ifndef LM87_AIN1
+       {LM87_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
+         &i2c_sysctl_real, NULL, &lm87_fan},
+       {LM87_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL, &i2c_proc_real,
+         &i2c_sysctl_real, NULL, &lm87_fan_div},
+#define LM87_FANDIV_FLAG
+#endif
+#ifndef LM87_AIN2
+       {LM87_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
+         &i2c_sysctl_real, NULL, &lm87_fan},
+#ifndef LM87_FANDIV_FLAG
+       {LM87_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL, &i2c_proc_real,
+         &i2c_sysctl_real, NULL, &lm87_fan_div},
+#endif /* LM87_FANDIV_FLAG */
+#endif /* LM87_AIN2 */
+#ifdef LM87_EXT2
+        {LM87_SYSCTL_TEMP3, "temp3", NULL, 0, 0644, NULL, &i2c_proc_real,
+         &i2c_sysctl_real, NULL, &lm87_temp},
+#endif
+       {LM87_SYSCTL_TEMP2, "temp2", NULL, 0, 0644, NULL, &i2c_proc_real,
+         &i2c_sysctl_real, NULL, &lm87_temp},
+       {LM87_SYSCTL_TEMP1, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
+         &i2c_sysctl_real, NULL, &lm87_temp},
+       {LM87_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
+         &i2c_sysctl_real, NULL, &lm87_alarms},
+       {LM87_SYSCTL_ANALOG_OUT, "analog_out", NULL, 0, 0644, NULL, &i2c_proc_real,
+         &i2c_sysctl_real, NULL, &lm87_analog_out},
+       {LM87_SYSCTL_VID, "vid", NULL, 0, 0444, NULL, &i2c_proc_real,
+         &i2c_sysctl_real, NULL, &lm87_vid},
+       {LM87_SYSCTL_VRM, "vrm", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &lm87_vrm},
+       {0}
+};
+
+static int lm87_attach_adapter(struct i2c_adapter *adapter)
+{
+       int error;
+       struct i2c_client_address_data  lm87_client_data;
+
+       lm87_client_data.normal_i2c       = addr_data.normal_i2c;
+       lm87_client_data.normal_i2c_range = addr_data.normal_i2c_range;
+       lm87_client_data.probe            = addr_data.probe;
+       lm87_client_data.probe_range      = addr_data.probe_range;
+       lm87_client_data.ignore           = addr_data.ignore;
+       lm87_client_data.ignore_range     = addr_data.ignore_range;
+       lm87_client_data.force            = addr_data.forces->force;
+
+       error = i2c_probe(adapter, &lm87_client_data, lm87_detect);
+       i2c_detect(adapter, &addr_data, lm87_detect);
+
+        return error;
+}
+
+static int lm87_detect(struct i2c_adapter *adapter, int address,
+                         unsigned short flags, int kind)
+{
+       int i;
+       struct i2c_client *new_client;
+       struct lm87_data *data;
+       int err = 0;
+       const char *type_name = "";
+       const char *client_name = "";
+
+       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
+               goto ERROR0;
+
+       /* OK. For now, we presume we have a valid client. We now create the
+          client structure, even though we cannot fill it completely yet.
+          But it allows us to access LM87_{read,write}_value. */
+
+       if (!(data = kmalloc(sizeof(struct lm87_data), GFP_KERNEL))) {
+               err = -ENOMEM;
+               goto ERROR0;
+       }
+
+       new_client = &data->client;
+       new_client->addr = address;
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &LM87_driver;
+       new_client->flags = 0;
+
+       /* Now, we do the remaining detection. */
+
+       if (kind < 0) {
+               if (((lm87_read_value(new_client, LM87_REG_CONFIG) & 0x80)
+                    != 0x00) ||
+                   (lm87_read_value(new_client, LM87_REG_COMPANY_ID) != 0x02))
+              goto ERROR1;
+       }
+
+       /* Fill in the remaining client fields and put into the global list */
+        type_name = "lm87";
+        client_name = "LM87 chip";
+       strcpy(new_client->name, client_name);
+       data->type = kind;
+
+       new_client->id = lm87_id++;
+       data->valid = 0;
+       init_MUTEX(&data->update_lock);
+
+       /* Tell the I2C layer a new client has arrived */
+       if ((err = i2c_attach_client(new_client)))
+               goto ERROR3;
+
+       /* Register a new directory entry with module sensors */
+       if ((i = i2c_register_entry(new_client,
+                                       type_name,
+                                       LM87_dir_table_template)) < 0) {
+               err = i;
+               goto ERROR4;
+       }
+       data->sysctl_id = i;
+
+       /* Initialize the LM87 chip */
+       lm87_init_client(new_client);
+       return 0;
+
+/* OK, this is not exactly good programming practice, usually. But it is
+   very code-efficient in this case. */
+
+      ERROR4:
+       i2c_detach_client(new_client);
+      ERROR3:
+      ERROR1:
+       kfree(data);
+      ERROR0:
+       return err;
+}
+
+static int lm87_detach_client(struct i2c_client *client)
+{
+       int err;
+
+       i2c_deregister_entry(((struct lm87_data *) (client->data))->
+                                sysctl_id);
+
+       if ((err = i2c_detach_client(client))) {
+               printk
+                   ("lm87.o: Client deregistration failed, client not detached.\n");
+               return err;
+       }
+
+       kfree(client->data);
+
+       return 0;
+}
+
+static int lm87_read_value(struct i2c_client *client, u8 reg)
+{
+       return 0xFF & i2c_smbus_read_byte_data(client, reg);
+}
+
+static int lm87_write_value(struct i2c_client *client, u8 reg, u8 value)
+{
+       return i2c_smbus_write_byte_data(client, reg, value);
+}
+
+/* Called when we have found a new LM87. It should set limits, etc. */
+static void lm87_init_client(struct i2c_client *client)
+{
+       struct lm87_data *data = client->data;
+
+       /* Reset all except Watchdog values and last conversion values
+          This sets fan-divs to 2, among others. This makes most other
+          initializations unnecessary */
+       lm87_write_value(client, LM87_REG_CONFIG, 0x80);
+
+        /* Setup Channel Mode register for configuration of monitoring 
+        * Default is 00000000b
+        *      bit 0 - Configures Fan 1/AIN 1 input (1 = AIN)
+        *      bit 1 - Configures Fan 2/AIN 2 input (1 = AIN)
+        *      bit 2 - Configures 2.5V&Vccp2/D2 input (1 = 2nd Therm.) 
+        *      bit 3 - Configures Vcc for 5V/3.3V reading (0 = 3.3V)
+        *      bit 4 - Configures IRQ0 Enable if = 1
+        *      bit 5 - Configures IRQ1 Enable if = 1
+        *      bit 6 - Configures IRQ2 Enable if = 1
+        *      bit 7 - Configures VID/IRQ input as interrupts if = 1
+        */
+
+/* I know, not clean, but it works. :'p */
+       lm87_write_value(client, LM87_REG_CHANNEL_MODE,
+#ifdef LM87_AIN1
+ 0x01
+#else
+0
+#endif
+ | 
+#ifdef LM87_AIN2
+ 0x02
+#else
+0
+#endif
+ |
+#ifdef LM87_EXT2
+ 0x04
+#else
+0
+#endif
+ | 
+#ifdef LM87_5V_VCC
+0x08
+#else   
+0
+#endif
+       );
+
+       data->vrm = DEFAULT_VRM;
+
+       /* Start monitoring */
+       lm87_write_value(client, LM87_REG_CONFIG, 0x01);
+}
+
+static void lm87_update_client(struct i2c_client *client)
+{
+       struct lm87_data *data = client->data;
+       int i;
+
+       down(&data->update_lock);
+
+       if ((jiffies - data->last_updated > HZ) ||  /* 1 sec cache */
+            (jiffies < data->last_updated)      || 
+             !data->valid) {
+               for (i = 0; i <= 5; i++) {  
+                data->in[i] = 
+                   lm87_read_value(client,LM87_REG_IN(i));
+                data->in_min[i] = 
+                   lm87_read_value(client,LM87_REG_IN_MIN(i));
+                data->in_max[i] = 
+                   lm87_read_value(client,LM87_REG_IN_MAX(i));
+               }
+                data->ain1 = 
+                   lm87_read_value(client,LM87_REG_FAN1_AIN1);
+                data->ain1_min =
+                   lm87_read_value(client,LM87_REG_AIN1_LOW);
+                data->ain1_max =
+                   lm87_read_value(client,LM87_REG_FAN1_AIN1_LIMIT);
+                data->ain2 = 
+                   lm87_read_value(client,LM87_REG_FAN2_AIN2);
+                data->ain2_min =
+                   lm87_read_value(client,LM87_REG_AIN2_LOW);
+                data->ain2_max =
+                   lm87_read_value(client,LM87_REG_FAN2_AIN2_LIMIT);
+
+               data->fan =
+                   lm87_read_value(client, LM87_REG_FAN1_AIN1);
+               data->fan_min =
+                   lm87_read_value(client, LM87_REG_FAN1_AIN1_LIMIT);
+               data->fan2 =
+                   lm87_read_value(client, LM87_REG_FAN2_AIN2);
+               data->fan2_min =
+                   lm87_read_value(client, LM87_REG_FAN2_AIN2_LIMIT);
+
+               data->ext2_temp =
+                   lm87_read_value(client, LM87_REG_2_5V_EXT_TEMP_2);
+               data->ext_temp =
+                   lm87_read_value(client, LM87_REG_EXT_TEMP_1);
+               data->int_temp =
+                   lm87_read_value(client, LM87_REG_INT_TEMP);
+
+               data->ext2_temp_max =
+                   lm87_read_value(client, LM87_REG_2_5V_EXT_TEMP_2_HIGH);
+               data->ext2_temp_min =
+                   lm87_read_value(client, LM87_REG_2_5V_EXT_TEMP_2_LOW);
+
+               data->ext_temp_max =
+                   lm87_read_value(client, LM87_REG_EXT_TEMP_1_HIGH);
+               data->ext_temp_min =
+                   lm87_read_value(client, LM87_REG_EXT_TEMP_1_LOW);
+
+               data->int_temp_max =
+                   lm87_read_value(client, LM87_REG_INT_TEMP_HIGH);
+               data->int_temp_min =
+                   lm87_read_value(client, LM87_REG_INT_TEMP_LOW);
+
+               i = lm87_read_value(client, LM87_REG_VID_FAN_DIV);
+               data->fan_div = (i >> 4) & 0x03;
+               data->fan2_div = (i >> 6) & 0x03;
+               data->vid = i & 0x0f;
+               data->vid |=
+                   (lm87_read_value(client, LM87_REG_VID4) & 0x01)
+                   << 4;
+               data->alarms =
+                   lm87_read_value(client, LM87_REG_INT1_STAT) +
+                   (lm87_read_value(client, LM87_REG_INT2_STAT) << 8);
+               data->analog_out =
+                   lm87_read_value(client, LM87_REG_ANALOG_OUT);
+               data->last_updated = jiffies;
+               data->valid = 1;
+       }
+       up(&data->update_lock);
+}
+
+
+/* The next few functions are the call-back functions of the /proc/sys and
+   sysctl files. Which function is used is defined in the ctl_table in
+   the extra1 field.
+   Each function must return the magnitude (power of 10 to divide the date
+   with) if it is called with operation==SENSORS_PROC_REAL_INFO. It must
+   put a maximum of *nrels elements in results reflecting the data of this
+   file, and set *nrels to the number it actually put in it, if operation==
+   SENSORS_PROC_REAL_READ. Finally, it must get upto *nrels elements from
+   results and write them to the chip, if operations==SENSORS_PROC_REAL_WRITE.
+   Note that on SENSORS_PROC_REAL_READ, I do not check whether results is
+   large enough (by checking the incoming value of *nrels). This is not very
+   good practice, but as long as you put less than about 5 values in results,
+   you can assume it is large enough. */
+void lm87_in(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       long scales[6] = { 250, 270, 
+#ifdef LM87_5V_VCC
+500,
+#else
+330,
+#endif
+               500, 1200, 270 };
+
+       struct lm87_data *data = client->data;
+       int nr = ctl_name - LM87_SYSCTL_IN0;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 2;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               lm87_update_client(client);
+               results[0] =
+                   ((long)data->in_min[nr] * scales[nr]) / 192;
+               results[1] =
+                   ((long)data->in_max[nr] * scales[nr]) / 192;
+               results[2] =
+                   ((long)data->in[nr] * scales[nr]) / 192;
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->in_min[nr] =
+                           (results[0] * 192) / scales[nr];
+                       lm87_write_value(client, LM87_REG_IN_MIN(nr),
+                                           data->in_min[nr]);
+               }
+               if (*nrels_mag >= 2) {
+                       data->in_max[nr] =
+                           (results[1] * 192) / scales[nr];
+                       lm87_write_value(client, LM87_REG_IN_MAX(nr),
+                                           data->in_max[nr]);
+               }
+       }
+}
+
+#if defined (LM87_AIN1) || defined (LM87_AIN2)
+void lm87_ain(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       struct lm87_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               lm87_update_client(client);
+               if (ctl_name == LM87_SYSCTL_AIN1) {
+                results[0] = data->ain1_min;
+                results[1] = data->ain1_max;
+                results[2] = data->ain1;
+               } else {
+                results[0] = data->ain2_min;
+                results[1] = data->ain2_max;
+                results[2] = data->ain2;
+               }
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                if (ctl_name == LM87_SYSCTL_AIN1) {
+                       data->ain1_min = results[0];
+                       lm87_write_value(client, LM87_REG_AIN1_LOW,
+                                           data->ain1_min);
+                } else {
+                       data->ain2_min = results[0];
+                       lm87_write_value(client, LM87_REG_AIN2_LOW,
+                                           data->ain2_min);
+                }
+               }
+               if (*nrels_mag >= 2) {
+                if (ctl_name == LM87_SYSCTL_AIN1) {
+                       data->ain1_max = results[1];
+                       lm87_write_value(client, LM87_REG_FAN1_AIN1_LIMIT,
+                                           data->ain1_max);
+                } else {
+                       data->ain2_max = results[1];
+                       lm87_write_value(client, LM87_REG_FAN2_AIN2_LIMIT,
+                                           data->ain2_max);
+                }
+               }
+       }
+}
+#endif
+
+void lm87_fan(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct lm87_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               lm87_update_client(client);
+               if (ctl_name == LM87_SYSCTL_FAN1) {
+                results[0] = FAN_FROM_REG(data->fan_min,
+                                         DIV_FROM_REG(data->fan_div));
+                results[1] = FAN_FROM_REG(data->fan, 
+                                        DIV_FROM_REG(data->fan_div));
+               } else {
+                results[0] = FAN_FROM_REG(data->fan2_min,
+                                         DIV_FROM_REG(data->fan2_div));
+                results[1] = FAN_FROM_REG(data->fan2, 
+                                        DIV_FROM_REG(data->fan2_div));
+               }
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 0) {
+                       if (ctl_name == LM87_SYSCTL_FAN1) {
+                        data->fan_min = FAN_TO_REG(results[0],
+                                                  DIV_FROM_REG
+                                                  (data->fan_div));
+                        lm87_write_value(client, LM87_REG_FAN1_AIN1_LIMIT,
+                                           data->fan_min);
+                       } else {
+                        data->fan2_min = FAN_TO_REG(results[0],
+                                                  DIV_FROM_REG
+                                                  (data->fan2_div));
+                        lm87_write_value(client, LM87_REG_FAN2_AIN2_LIMIT,
+                                           data->fan2_min);
+                       }
+               }
+       }
+}
+
+
+void lm87_temp(struct i2c_client *client, int operation, int ctl_name,
+                 int *nrels_mag, long *results)
+{
+       struct lm87_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+       else if (operation == SENSORS_PROC_REAL_READ) 
+       {
+          lm87_update_client(client);
+
+          /* find out which temp. is being requested */
+          if (ctl_name == LM87_SYSCTL_TEMP3) 
+          {
+               results[0] = TEMP_LIMIT_FROM_REG(data->ext2_temp_max);
+               results[1] = TEMP_LIMIT_FROM_REG(data->ext2_temp_min);
+               results[2] = TEMP_FROM_REG(data->ext2_temp);
+          }
+          else if(ctl_name == LM87_SYSCTL_TEMP2)
+          {
+               results[0] = TEMP_LIMIT_FROM_REG(data->ext_temp_max);
+               results[1] = TEMP_LIMIT_FROM_REG(data->ext_temp_min);
+               results[2] = TEMP_FROM_REG(data->ext_temp);
+          }
+          else if(ctl_name == LM87_SYSCTL_TEMP1)
+          {
+               results[0] = TEMP_LIMIT_FROM_REG(data->int_temp_max);
+               results[1] = TEMP_LIMIT_FROM_REG(data->int_temp_min);
+               results[2] = TEMP_FROM_REG(data->int_temp);
+          }
+          *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                  if (ctl_name == LM87_SYSCTL_TEMP3) {
+                       data->ext2_temp_max = TEMP_LIMIT_TO_REG(results[0]);
+                       lm87_write_value(client, LM87_REG_2_5V_EXT_TEMP_2_HIGH,
+                                           data->ext2_temp_max);
+                  }
+                  if (ctl_name == LM87_SYSCTL_TEMP2) {
+                       data->ext_temp_max = TEMP_LIMIT_TO_REG(results[0]);
+                       lm87_write_value(client, LM87_REG_EXT_TEMP_1_HIGH,
+                                           data->ext_temp_max);
+                  }
+                  if (ctl_name == LM87_SYSCTL_TEMP1) {
+                       data->int_temp_max = TEMP_LIMIT_TO_REG(results[0]);
+                       lm87_write_value(client, LM87_REG_INT_TEMP_HIGH,
+                                           data->int_temp_max);
+                  }
+               }
+               if (*nrels_mag >= 2) {
+                  if (ctl_name == LM87_SYSCTL_TEMP3) {
+                       data->ext2_temp_min = TEMP_LIMIT_TO_REG(results[1]);
+                       lm87_write_value(client, LM87_REG_2_5V_EXT_TEMP_2_LOW,
+                                           data->ext2_temp_min);
+                  }
+                  if (ctl_name == LM87_SYSCTL_TEMP2) {
+                       data->ext_temp_min = TEMP_LIMIT_TO_REG(results[1]);
+                       lm87_write_value(client, LM87_REG_EXT_TEMP_1_LOW,
+                                           data->ext_temp_min);
+                  }
+                  if (ctl_name == LM87_SYSCTL_TEMP1) {
+                       data->int_temp_min = TEMP_LIMIT_TO_REG(results[1]);
+                       lm87_write_value(client, LM87_REG_INT_TEMP_LOW,
+                                           data->int_temp_min);
+                  }
+               }
+       }
+}
+
+void lm87_alarms(struct i2c_client *client, int operation, int ctl_name,
+                   int *nrels_mag, long *results)
+{
+       struct lm87_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               lm87_update_client(client);
+               results[0] = ALARMS_FROM_REG(data->alarms);
+               *nrels_mag = 1;
+       }
+}
+
+void lm87_fan_div(struct i2c_client *client, int operation,
+                    int ctl_name, int *nrels_mag, long *results)
+{
+/* This gets a little hairy depending on the hardware config */
+
+       struct lm87_data *data = client->data;
+       int old;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               lm87_update_client(client);
+#ifndef LM87_AIN1
+               results[0] = DIV_FROM_REG(data->fan_div);
+# ifndef LM87_AIN2
+               results[1] = DIV_FROM_REG(data->fan2_div);
+               *nrels_mag = 2;
+# else
+               *nrels_mag = 1;
+# endif
+#else /* Must be referring to fan 2 */
+               results[0] = DIV_FROM_REG(data->fan2_div);
+               *nrels_mag = 1;
+#endif
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               old = lm87_read_value(client, LM87_REG_VID_FAN_DIV);
+/* Note: it's OK to change fan2 div even if fan2 isn't enabled */
+#ifndef LM87_AIN1
+               if (*nrels_mag >= 2) {
+                       data->fan2_div = DIV_TO_REG(results[1]);
+                       old = (old & 0x3f) | (data->fan2_div << 6);
+               }
+               if (*nrels_mag >= 1) {
+                       data->fan_div = DIV_TO_REG(results[0]);
+                       old = (old & 0xcf) | (data->fan_div << 4);
+                       lm87_write_value(client, LM87_REG_VID_FAN_DIV, old);
+               }
+#else /* Must be referring to fan 2 */
+               if (*nrels_mag >= 1) {
+                       data->fan2_div = DIV_TO_REG(results[0]);
+                       old = (old & 0xcf) | (data->fan2_div << 6);
+                       lm87_write_value(client, LM87_REG_VID_FAN_DIV, old);
+               }
+#endif
+       }
+}
+
+void lm87_analog_out(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results)
+{
+       struct lm87_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               lm87_update_client(client);
+               results[0] = data->analog_out;
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->analog_out = results[0];
+                       lm87_write_value(client, LM87_REG_ANALOG_OUT,
+                                           data->analog_out);
+               }
+       }
+}
+
+void lm87_vid(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct lm87_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 3;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               lm87_update_client(client);
+               results[0] = vid_from_reg(data->vid, data->vrm);
+               *nrels_mag = 1;
+       }
+}
+
+void lm87_vrm(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct lm87_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               results[0] = data->vrm;
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1)
+                       data->vrm = results[0];
+       }
+}
+
+static int __init sm_lm87_init(void)
+{
+       printk("lm87.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       return i2c_add_driver(&LM87_driver);
+}
+
+static void __exit sm_lm87_exit(void)
+{
+       i2c_del_driver(&LM87_driver);
+}
+
+
+
+MODULE_LICENSE("GPL");
+
+MODULE_AUTHOR
+    ("Frodo Looijaard <frodol@dds.nl>, Philip Edelbrock <phil@netroedge.com>, "
+     "Mark Studebaker <mdsxyz123@yahoo.com>, and Stephen Rousset <stephen.rousset@rocketlogix.com>");
+
+MODULE_DESCRIPTION("LM87 driver");
+
+module_init(sm_lm87_init);
+module_exit(sm_lm87_exit);
--- linux-old/drivers/sensors/lm90.c    Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/lm90.c        Mon Dec 13 20:18:49 2004
@@ -0,0 +1,782 @@
+/*
+ * lm90.c - Part of lm_sensors, Linux kernel modules for hardware
+ *          monitoring
+ * Copyright (C) 2003-2004  Jean Delvare <khali@linux-fr.org>
+ *
+ * Based on the lm83 driver. The LM90 is a sensor chip made by National
+ * Semiconductor. It reports up to two temperatures (its own plus up to
+ * one external one) with a 0.125 deg resolution (1 deg for local
+ * temperature) and a 3-4 deg accuracy. Complete datasheet can be
+ * obtained from National's website at:
+ *   http://www.national.com/pf/LM/LM90.html
+ *
+ * This driver also supports the LM89 and LM99, two other sensor chips
+ * made by National Semiconductor. Both have an increased remote
+ * temperature measurement accuracy (1 degree), and the LM99
+ * additionally shifts remote temperatures (measured and limits) by 16
+ * degrees, which allows for higher temperatures measurement. The
+ * driver doesn't handle it since it can be done easily in user-space.
+ * Complete datasheets can be obtained from National's website at:
+ *   http://www.national.com/pf/LM/LM89.html
+ *   http://www.national.com/pf/LM/LM99.html
+ * Note that there is no way to differenciate between both chips.
+ *
+ * This driver also supports the LM86, another sensor chip made by
+ * National Semiconductor. It is exactly similar to the LM90 except it
+ * has a higher accuracy.
+ * Complete datasheet can be obtained from National's website at:
+ *   http://www.national.com/pf/LM/LM86.html
+ *
+ * This driver also supports the ADM1032, a sensor chip made by Analog
+ * Devices. That chip is similar to the LM90, with a few differences
+ * that are not handled by this driver. Complete datasheet can be
+ * obtained from Analog's website at:
+ *   http://products.analog.com/products/info.asp?product=ADM1032
+ * Among others, it has a higher accuracy than the LM90, much like the
+ * LM86 does.
+ *
+ * This driver also supports the MAX6657 and MAX6658, sensor chips made
+ * by Maxim. These chips are similar to the LM86. Complete datasheet
+ * can be obtained at Maxim's website at:
+ *   http://www.maxim-ic.com/quick_view2.cfm/qv_pk/2578
+ * Note that there is no way to differenciate between both chips (but
+ * no need either).
+ *
+ * Since the LM90 was the first chipset supported by this driver, most
+ * comments will refer to this chipset, but are actually general and
+ * concern all supported chipsets, unless mentioned otherwise.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+#ifndef I2C_DRIVERID_LM90
+#define I2C_DRIVERID_LM90      1042
+#endif
+
+/*
+ * Addresses to scan
+ * Address is fully defined internally and cannot be changed.
+ * LM86, LM89, LM90, LM99, ADM1032, MAX6657 and MAX6658 have address 0x4c.
+ * LM89-1, and LM99-1 have address 0x4d.
+ */
+
+static unsigned short normal_i2c[] = { 0x4c, 0x4d, SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { SENSORS_I2C_END };
+static unsigned int normal_isa[] = { SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+/*
+ * Insmod parameters
+ */
+
+SENSORS_INSMOD_5(lm90, adm1032, lm99, lm86, max6657);
+
+/*
+ * The LM90 registers
+ */
+
+#define LM90_REG_R_MAN_ID        0xFE
+#define LM90_REG_R_CHIP_ID       0xFF
+#define LM90_REG_R_CONFIG1       0x03
+#define LM90_REG_W_CONFIG1       0x09
+#define LM90_REG_R_CONFIG2       0xBF
+#define LM90_REG_W_CONFIG2       0xBF
+#define LM90_REG_R_CONVRATE      0x04
+#define LM90_REG_W_CONVRATE      0x0A
+#define LM90_REG_R_STATUS        0x02
+#define LM90_REG_R_LOCAL_TEMP    0x00
+#define LM90_REG_R_LOCAL_HIGH    0x05
+#define LM90_REG_W_LOCAL_HIGH    0x0B
+#define LM90_REG_R_LOCAL_LOW     0x06
+#define LM90_REG_W_LOCAL_LOW     0x0C
+#define LM90_REG_R_LOCAL_CRIT    0x20
+#define LM90_REG_W_LOCAL_CRIT    0x20
+#define LM90_REG_R_REMOTE_TEMPH  0x01
+#define LM90_REG_R_REMOTE_TEMPL  0x10
+#define LM90_REG_R_REMOTE_OFFSH  0x11
+#define LM90_REG_W_REMOTE_OFFSH  0x11
+#define LM90_REG_R_REMOTE_OFFSL  0x12
+#define LM90_REG_W_REMOTE_OFFSL  0x12
+#define LM90_REG_R_REMOTE_HIGHH  0x07
+#define LM90_REG_W_REMOTE_HIGHH  0x0D
+#define LM90_REG_R_REMOTE_HIGHL  0x13
+#define LM90_REG_W_REMOTE_HIGHL  0x13
+#define LM90_REG_R_REMOTE_LOWH   0x08
+#define LM90_REG_W_REMOTE_LOWH   0x0E
+#define LM90_REG_R_REMOTE_LOWL   0x14
+#define LM90_REG_W_REMOTE_LOWL   0x14
+#define LM90_REG_R_REMOTE_CRIT   0x19
+#define LM90_REG_W_REMOTE_CRIT   0x19
+#define LM90_REG_R_TCRIT_HYST    0x21
+#define LM90_REG_W_TCRIT_HYST    0x21
+
+/*
+ * Conversions and various macros
+ * The LM90 uses signed 8-bit values for the local temperatures,
+ * and signed 11-bit values for the remote temperatures (except
+ * T_CRIT). The 11-bit conversion formulas may not round negative
+ * numbers perfectly, but who cares?
+ */
+
+#define TEMP1_FROM_REG(val)  (val & 0x80 ? val-0x100 : val)
+#define TEMP1_TO_REG(val)    (val < 0 ? val+0x100 : val)
+#define TEMP2_FROM_REG(val)  (((val & 0x8000 ? val-0x10000 : val) \
+                             * 10 + 128) >> 8)
+#define TEMP2_TO_REG(val)    (((val << 8) / 10 + (val < 0 ? \
+                             0x10000 : 0)) & 0xFFE0)
+#define HYST_TO_REG(val)     (val < 0 ? 0 : val > 31 ? 31 : val)
+
+/*
+ * Functions declaration
+ */
+
+static int lm90_attach_adapter(struct i2c_adapter *adapter);
+static int lm90_detect(struct i2c_adapter *adapter, int address,
+       unsigned short flags, int kind);
+static void lm90_init_client(struct i2c_client *client);
+static int lm90_detach_client(struct i2c_client *client);
+static void lm90_local_temp(struct i2c_client *client, int operation,
+       int ctl_name, int *nrels_mag, long *results);
+static void lm90_remote_temp(struct i2c_client *client, int operation,
+       int ctl_name, int *nrels_mag, long *results);
+static void lm90_local_tcrit(struct i2c_client *client, int operation,
+       int ctl_name, int *nrels_mag, long *results);
+static void lm90_remote_tcrit(struct i2c_client *client, int operation,
+       int ctl_name, int *nrels_mag, long *results);
+static void lm90_local_hyst(struct i2c_client *client, int operation,
+       int ctl_name, int *nrels_mag, long *results);
+static void lm90_remote_hyst(struct i2c_client *client, int operation,
+       int ctl_name, int *nrels_mag, long *results);
+static void lm90_alarms(struct i2c_client *client, int operation,
+       int ctl_name, int *nrels_mag, long *results);
+
+/*
+ * Driver data (common to all clients)
+ */
+
+static struct i2c_driver lm90_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "LM90/ADM1032 sensor driver",
+       .id             = I2C_DRIVERID_LM90,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = lm90_attach_adapter,
+       .detach_client  = lm90_detach_client
+};
+
+/*
+ * Client data (each client gets its own)
+ */
+
+struct lm90_data
+{
+       struct i2c_client client;
+       int sysctl_id;
+
+       struct semaphore update_lock;
+       char valid; /* zero until following fields are valid */
+       unsigned long last_updated; /* in jiffies */
+
+       /* registers values */
+       u8 local_temp, local_high, local_low;
+       u16 remote_temp, remote_high, remote_low; /* combined */
+       u8 local_crit, remote_crit;
+       u8 hyst; /* linked to two sysctl files (hyst1 RW, hyst2 RO) */
+       u16 alarms; /* bitvector, combined */
+};
+
+/*
+ * Proc entries
+ * These files are created for each detected LM90.
+ */
+
+/* -- SENSORS SYSCTL START -- */
+
+#define LM90_SYSCTL_LOCAL_TEMP    1200
+#define LM90_SYSCTL_REMOTE_TEMP   1201
+#define LM90_SYSCTL_LOCAL_TCRIT   1204
+#define LM90_SYSCTL_REMOTE_TCRIT  1205
+#define LM90_SYSCTL_LOCAL_HYST    1207
+#define LM90_SYSCTL_REMOTE_HYST   1208
+#define LM90_SYSCTL_ALARMS        1210
+
+#define LM90_ALARM_LOCAL_HIGH     0x40
+#define LM90_ALARM_LOCAL_LOW      0x20
+#define LM90_ALARM_LOCAL_CRIT     0x01
+#define LM90_ALARM_REMOTE_HIGH    0x10
+#define LM90_ALARM_REMOTE_LOW     0x08
+#define LM90_ALARM_REMOTE_CRIT    0x02
+#define LM90_ALARM_REMOTE_OPEN    0x04
+
+/* -- SENSORS SYSCTL END -- */
+
+
+static ctl_table lm90_dir_table_template[] =
+{
+       {LM90_SYSCTL_LOCAL_TEMP, "temp1", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &lm90_local_temp},
+       {LM90_SYSCTL_REMOTE_TEMP, "temp2", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &lm90_remote_temp},
+       {LM90_SYSCTL_LOCAL_TCRIT, "tcrit1", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &lm90_local_tcrit},
+       {LM90_SYSCTL_REMOTE_TCRIT, "tcrit2", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &lm90_remote_tcrit},
+       {LM90_SYSCTL_LOCAL_HYST, "hyst1", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &lm90_local_hyst},
+       {LM90_SYSCTL_REMOTE_HYST, "hyst2", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &lm90_remote_hyst},
+       {LM90_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &lm90_alarms},
+       {0}
+};
+
+/*
+ * Internal variables
+ */
+
+static int lm90_id = 0;
+
+/*
+ * Real code
+ */
+
+static int lm90_attach_adapter(struct i2c_adapter *adapter)
+{
+       return i2c_detect(adapter, &addr_data, lm90_detect);
+}
+
+/*
+ * The following function does more than just detection. If detection
+ * succeeds, it also registers the new chip.
+ */
+static int lm90_detect(struct i2c_adapter *adapter, int address,
+       unsigned short flags, int kind)
+{
+       struct i2c_client *new_client;
+       struct lm90_data *data;
+       int err = 0;
+       const char *type_name = "";
+       const char *client_name = "";
+
+#ifdef DEBUG
+       if (i2c_is_isa_adapter(adapter))
+       {
+               printk("lm90.o: Called for an ISA bus adapter, aborting.\n");
+               return 0;
+       }
+#endif
+
+       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
+       {
+#ifdef DEBUG
+               printk("lm90.o: I2C bus doesn't support byte read mode, "
+                      "skipping.\n");
+#endif
+               return 0;
+       }
+
+       if (!(data = kmalloc(sizeof(struct lm90_data), GFP_KERNEL)))
+       {
+               printk("lm90.o: Out of memory in lm90_detect (new_client).\n");
+               return -ENOMEM;
+       }
+
+       /*
+        * The common I2C client data is placed right before the
+        * LM90-specific data. The LM90-specific data is pointed to by the
+        * data field from the I2C client data.
+        */
+
+       new_client = &data->client;
+       new_client->addr = address;
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &lm90_driver;
+       new_client->flags = 0;
+
+       /*
+        * 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. 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 */
+       {
+               u8 man_id, chip_id, reg_config1, reg_convrate;
+
+               man_id = i2c_smbus_read_byte_data(new_client,
+                       LM90_REG_R_MAN_ID);
+               chip_id = i2c_smbus_read_byte_data(new_client,
+                       LM90_REG_R_CHIP_ID);
+               reg_config1 = i2c_smbus_read_byte_data(new_client,
+                       LM90_REG_R_CONFIG1);
+               reg_convrate = i2c_smbus_read_byte_data(new_client,
+                       LM90_REG_R_CONVRATE);
+               
+               if (man_id == 0x01) /* National Semiconductor */
+               {
+                       u8 reg_config2;
+
+                       reg_config2 = i2c_smbus_read_byte_data(new_client,
+                               LM90_REG_R_CONFIG2);
+
+                       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;
+                               else if (address == 0x4C
+                                && (chip_id & 0xF0) == 0x10) /* LM86 */
+                                       kind = lm99;
+                       }
+               }
+               else if (man_id == 0x41) /* Analog Devices */
+               {
+                       if (address == 0x4C
+                        && (chip_id & 0xF0) == 0x40 /* ADM1032 */
+                        && (reg_config1 & 0x3F) == 0x00
+                        && reg_convrate <= 0x0A)
+                               kind = adm1032;
+               }
+               else if (man_id == 0x4D) /* Maxim */
+               {
+                       if (address == 0x4C
+                        && (reg_config1 & 0x1F) == 0
+                        && reg_convrate <= 0x09)
+                               kind = max6657;
+               }
+       }
+
+       if (kind <= 0) /* identification failed */
+       {
+               printk("lm90.o: Unsupported chip.\n");
+               goto ERROR1;
+       }
+
+       if (kind == lm90)
+       {
+               type_name = "lm90";
+               client_name = "LM90 chip";
+       }
+       else if (kind == adm1032)
+       {
+               type_name = "adm1032";
+               client_name = "ADM1032 chip";
+       }
+       else if (kind == lm99)
+       {
+               type_name = "lm99";
+               client_name = "LM99 chip";
+       }
+       else if (kind == lm86)
+       {
+               type_name = "lm86";
+               client_name = "LM86 chip";
+       }
+       else if (kind == max6657)
+       {
+               type_name = "max6657";
+               client_name = "MAX6657 chip";
+       }
+       else
+       {
+               printk("lm90.o: Unknown kind %d.\n", kind);
+               goto ERROR1;
+       }
+
+       /*
+        * OK, we got a valid chip so we can fill in the remaining client
+        * fields.
+        */
+
+       strcpy(new_client->name, client_name);
+       new_client->id = lm90_id++;
+       data->valid = 0;
+       init_MUTEX(&data->update_lock);
+
+       /*
+        * Tell the I2C layer a new client has arrived.
+        */
+
+       if ((err = i2c_attach_client(new_client)))
+       {
+#ifdef DEBUG
+               printk("lm90.o: Failed attaching client.\n");
+#endif
+               goto ERROR1;
+       }
+
+       /*
+        * Register a new directory entry.
+        */
+
+       if ((err = i2c_register_entry(new_client, type_name,
+            lm90_dir_table_template)) < 0)
+       {
+#ifdef DEBUG
+               printk("lm90.o: Failed registering directory entry.\n");
+#endif
+               goto ERROR2;
+       }
+       data->sysctl_id = err;
+
+       /*
+        * Initialize the LM90 chip.
+        */
+
+       lm90_init_client(new_client);
+       return 0;
+
+       ERROR2:
+       i2c_detach_client(new_client);
+       ERROR1:
+       kfree(data);
+       return err;
+}
+
+static void lm90_init_client(struct i2c_client *client)
+{
+       u8 config;
+
+       /*
+        * Start the conversions.
+        */
+
+       i2c_smbus_write_byte_data(client, LM90_REG_W_CONVRATE,
+               5); /* 2 Hz */
+       config = i2c_smbus_read_byte_data(client, LM90_REG_R_CONFIG1);
+       if (config & 0x40)
+               i2c_smbus_write_byte_data(client, LM90_REG_W_CONFIG1,
+                       config & 0xBF); /* run */
+}
+
+
+static int lm90_detach_client(struct i2c_client *client)
+{
+       int err;
+
+       i2c_deregister_entry(((struct lm90_data *) (client->data))->sysctl_id);
+       if ((err = i2c_detach_client(client)))
+       {
+               printk("lm90.o: Client deregistration failed, client not "
+                      "detached.\n");
+               return err;
+       }
+
+       kfree(client->data);
+       return 0;
+}
+
+static void lm90_update_client(struct i2c_client *client)
+{
+       struct lm90_data *data = client->data;
+
+       down(&data->update_lock);
+
+       if ((jiffies - data->last_updated > HZ * 2) ||
+           (jiffies < data->last_updated) || !data->valid)
+       {
+               u8 oldh, newh;
+#ifdef DEBUG
+               printk("lm90.o: Updating data.\n");
+#endif
+
+               data->local_temp =
+                       i2c_smbus_read_byte_data(client, LM90_REG_R_LOCAL_TEMP);
+               data->local_high =
+                       i2c_smbus_read_byte_data(client, LM90_REG_R_LOCAL_HIGH);
+               data->local_low =
+                       i2c_smbus_read_byte_data(client, LM90_REG_R_LOCAL_LOW);
+               data->local_crit =
+                       i2c_smbus_read_byte_data(client, LM90_REG_R_LOCAL_CRIT);
+
+               /*
+                * There is a trick here. We have to read two registers to
+                * have the remote sensor temperature, but we have to beware
+                * a conversion could occur inbetween the readings. The
+                * datasheet says we should either use the one-shot
+                * conversion register, which we don't want to do (disables
+                * hardware monitoring) or monitor the busy bit, which is
+                * impossible (we can't read the values and monitor that bit
+                * at the exact same time). So the solution used here is to
+                * read the high byte once, then the low byte, then the high
+                * byte again. If the new high byte matches the old one,
+                * then we have a valid reading. Else we have to read the low
+                * byte again, and now we believe we have a correct reading.
+                */
+
+               oldh =
+                       i2c_smbus_read_byte_data(client, LM90_REG_R_REMOTE_TEMPH);
+               data->remote_temp =
+                       i2c_smbus_read_byte_data(client, LM90_REG_R_REMOTE_TEMPL);
+               newh =
+                       i2c_smbus_read_byte_data(client, LM90_REG_R_REMOTE_TEMPH);
+               if (newh != oldh)
+               {
+                       data->remote_temp =
+                               i2c_smbus_read_byte_data(client, LM90_REG_R_REMOTE_TEMPL);
+#ifdef DEBUG
+                       oldh = /* actually newer */
+                               i2c_smbus_read_byte_data(client, LM90_REG_R_REMOTE_TEMPH);
+                       if (newh != oldh)
+                               printk("lm90.o: Remote temperature may be wrong.\n");
+#endif
+               }
+               data->remote_temp |= (newh << 8);
+               data->remote_high =
+                       (i2c_smbus_read_byte_data(client, LM90_REG_R_REMOTE_HIGHH) << 8)
+                       + i2c_smbus_read_byte_data(client, LM90_REG_R_REMOTE_HIGHL);
+               data->remote_low =
+                       (i2c_smbus_read_byte_data(client, LM90_REG_R_REMOTE_LOWH) << 8)
+                       + i2c_smbus_read_byte_data(client, LM90_REG_R_REMOTE_LOWL);
+               data->remote_crit =
+                       i2c_smbus_read_byte_data(client, LM90_REG_R_REMOTE_CRIT);
+
+               data->hyst =
+                       i2c_smbus_read_byte_data(client, LM90_REG_R_TCRIT_HYST);
+               data->alarms =
+                       i2c_smbus_read_byte_data(client, LM90_REG_R_STATUS);
+
+               data->last_updated = jiffies;
+               data->valid = 1;
+       }
+
+       up(&data->update_lock);
+}
+
+static void lm90_local_temp(struct i2c_client *client, int operation,
+       int ctl_name, int *nrels_mag, long *results)
+{
+       struct lm90_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0; /* magnitude */
+       else if (operation == SENSORS_PROC_REAL_READ)
+       {
+               lm90_update_client(client);
+               results[0] = TEMP1_FROM_REG(data->local_high);
+               results[1] = TEMP1_FROM_REG(data->local_low);
+               results[2] = TEMP1_FROM_REG(data->local_temp);
+               *nrels_mag = 3;
+       }
+       else if (operation == SENSORS_PROC_REAL_WRITE)
+       {
+               if (*nrels_mag >= 1)
+               {
+                       data->local_high = TEMP1_TO_REG(results[0]);
+                       i2c_smbus_write_byte_data(client, LM90_REG_W_LOCAL_HIGH,
+                               data->local_high);
+               }
+               if (*nrels_mag >= 2)
+               {
+                       data->local_low = TEMP1_TO_REG(results[1]);
+                       i2c_smbus_write_byte_data(client, LM90_REG_W_LOCAL_LOW,
+                               data->local_low);
+               }
+       }
+}
+
+static void lm90_remote_temp(struct i2c_client *client, int operation,
+       int ctl_name, int *nrels_mag, long *results)
+{
+       struct lm90_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1; /* magnitude */
+       else if (operation == SENSORS_PROC_REAL_READ)
+       {
+               lm90_update_client(client);
+               results[0] = TEMP2_FROM_REG(data->remote_high);
+               results[1] = TEMP2_FROM_REG(data->remote_low);
+               results[2] = TEMP2_FROM_REG(data->remote_temp);
+               *nrels_mag = 3;
+       }
+       else if (operation == SENSORS_PROC_REAL_WRITE)
+       {
+               if (*nrels_mag >= 1)
+               {
+                       data->remote_high = TEMP2_TO_REG(results[0]);
+                       i2c_smbus_write_byte_data(client, LM90_REG_W_REMOTE_HIGHH,
+                               data->remote_high >> 8);
+                       i2c_smbus_write_byte_data(client, LM90_REG_W_REMOTE_HIGHL,
+                               data->remote_high & 0xFF);
+               }
+               if (*nrels_mag >= 2)
+               {
+                       data->remote_low = TEMP2_TO_REG(results[1]);
+                       i2c_smbus_write_byte_data(client, LM90_REG_W_REMOTE_LOWH,
+                               data->remote_low >> 8);
+                       i2c_smbus_write_byte_data(client, LM90_REG_W_REMOTE_LOWL,
+                               data->remote_low & 0xFF);
+               }
+       }
+}
+
+static void lm90_local_tcrit(struct i2c_client *client, int operation,
+       int ctl_name, int *nrels_mag, long *results)
+{
+       struct lm90_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0; /* magnitude */
+       else if (operation == SENSORS_PROC_REAL_READ)
+       {
+               lm90_update_client(client);
+               results[0] = TEMP1_FROM_REG(data->local_crit);
+               *nrels_mag = 1;
+       }
+       else if (operation == SENSORS_PROC_REAL_WRITE)
+       {
+               if (*nrels_mag >= 1)
+               {
+                       data->local_crit = TEMP1_TO_REG(results[0]);
+                       i2c_smbus_write_byte_data(client, LM90_REG_W_LOCAL_CRIT,
+                               data->local_crit);
+               }
+       }
+}
+
+static void lm90_remote_tcrit(struct i2c_client *client, int operation,
+       int ctl_name, int *nrels_mag, long *results)
+{
+       struct lm90_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0; /* magnitude */
+       else if (operation == SENSORS_PROC_REAL_READ)
+       {
+               lm90_update_client(client);
+               results[0] = TEMP1_FROM_REG(data->remote_crit);
+               *nrels_mag = 1;
+       }
+       else if (operation == SENSORS_PROC_REAL_WRITE)
+       {
+               if (*nrels_mag >= 1)
+               {
+                       data->remote_crit = TEMP1_TO_REG(results[0]);
+                       i2c_smbus_write_byte_data(client, LM90_REG_W_REMOTE_CRIT,
+                               data->remote_crit);
+               }
+       }
+}
+
+/*
+ * One quick note about hysteresis. Internally, the hysteresis value
+ * is held in a single register by the LM90, as a relative value.
+ * This relative value applies to both the local critical temperature
+ * and the remote critical temperature. Since all temperatures exported
+ * through procfs have to be absolute, we have to do some conversions.
+ * The solution retained here is to export two absolute values, one for
+ * each critical temperature. In order not to confuse the users too
+ * much, only one file is writable. Would we fail to do so, users
+ * would probably attempt to write to both files, as if they were
+ * independant, and since they aren't, they wouldn't understand why
+ * setting one affects the other one (and would probably claim there's
+ * a bug in the driver).
+ */
+
+static void lm90_local_hyst(struct i2c_client *client, int operation,
+       int ctl_name, int *nrels_mag, long *results)
+{
+       struct lm90_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0; /* magnitude */
+       else if (operation == SENSORS_PROC_REAL_READ)
+       {
+               lm90_update_client(client);
+               results[0] = TEMP1_FROM_REG(data->local_crit) -
+                       TEMP1_FROM_REG(data->hyst);
+               *nrels_mag = 1;
+       }
+       else if (operation == SENSORS_PROC_REAL_WRITE)
+       {
+               if (*nrels_mag >= 1)
+               {
+                       data->hyst = HYST_TO_REG(data->local_crit - results[0]);
+                       i2c_smbus_write_byte_data(client, LM90_REG_W_TCRIT_HYST,
+                               data->hyst);
+               }
+       }
+}
+
+static void lm90_remote_hyst(struct i2c_client *client, int operation,
+       int ctl_name, int *nrels_mag, long *results)
+{
+       struct lm90_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0; /* magnitude */
+       else if (operation == SENSORS_PROC_REAL_READ)
+       {
+               lm90_update_client(client);
+               results[0] = TEMP1_FROM_REG(data->remote_crit) -
+                       TEMP1_FROM_REG(data->hyst);
+               *nrels_mag = 1;
+       }
+}
+
+static void lm90_alarms(struct i2c_client *client, int operation,
+       int ctl_name, int *nrels_mag, long *results)
+{
+       struct lm90_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0; /* magnitude */
+       else if (operation == SENSORS_PROC_REAL_READ)
+       {
+               lm90_update_client(client);
+               results[0] = data->alarms;
+               *nrels_mag = 1;
+       }
+}
+
+static int __init sm_lm90_init(void)
+{
+       printk(KERN_INFO "lm90.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       return i2c_add_driver(&lm90_driver);
+}
+
+static void __exit sm_lm90_exit(void)
+{
+       i2c_del_driver(&lm90_driver);
+}
+
+MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
+MODULE_DESCRIPTION("LM90/ADM1032 sensor driver");
+MODULE_LICENSE("GPL");
+
+module_init(sm_lm90_init);
+module_exit(sm_lm90_exit);
--- linux-old/drivers/sensors/lm92.c    Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/lm92.c        Mon Dec 13 20:18:49 2004
@@ -0,0 +1,421 @@
+
+/*
+ * LM92 - Part of lm_sensors, Linux kernel modules for hardware
+ *        monitoring
+ *
+ * Author: Abraham van der Merwe <abraham@2d3d.co.za>
+ *
+ * Linux support for the National Semiconductor LM92 Temperature
+ * Sensor.
+ *
+ * Based on code from the lm-sensors project which is available
+ * at http://www.lm-sensors.nu/. lm87.c have been particularly
+ * helpful (:
+ *
+ * This source code is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ */
+
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/string.h>
+#include <linux/slab.h>
+#include <linux/init.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/proc_fs.h>
+#include <linux/sysctl.h>
+#include <asm/semaphore.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+/* if defined, 4 faults must occur consecutively to set alarm flags */
+/* #define ENABLE_FAULT_QUEUE */
+
+#define LM92_REG_TEMPERATURE           0x00    /* ro, 16-bit   */
+#define LM92_REG_CONFIGURATION         0x01    /* rw, 8-bit    */
+#define LM92_REG_TRIP_HYSTERESIS       0x02    /* rw, 16-bit   */
+#define LM92_REG_TRIP_CRITICAL         0x03    /* rw, 16-bit   */
+#define LM92_REG_TRIP_LOW                      0x04    /* rw, 16-bit   */
+#define LM92_REG_TRIP_HIGH                     0x05    /* rw, 16-bit   */
+#define LM92_REG_MANUFACTURER          0x07    /* ro, 16-bit   */
+
+#define LM92_MANUFACTURER_ID           0x8001
+
+#define TEMP_MIN       (-4096)
+#define TEMP_MAX       4095
+
+#define LIMIT(x) do {                                                  \
+               if ((x) < TEMP_MIN) (x) = TEMP_MIN;             \
+               if ((x) > TEMP_MAX) (x) = TEMP_MAX;             \
+       } while (0)
+
+#define PROC_TO_NATIVE(x) ((x) / 625)
+#define NATIVE_TO_PROC(x) ((x) * 625)
+#define CELSIUS(x) ((x) * 16)
+
+static void lm92_temp (struct i2c_client *client,int operation,int ctl_name,int *nrels_mag,long *results);
+static void lm92_alarms (struct i2c_client *client,int operation,int ctl_name,int *nrels_mag,long *results);
+
+/* -- SENSORS SYSCTL START -- */
+#define LM92_SYSCTL_ALARMS             2001    /* high, low, critical */
+#define LM92_SYSCTL_TEMP               1200    /* high, low, critical, hysteresis, input */
+
+#define LM92_ALARM_TEMP_HIGH   0x01
+#define LM92_ALARM_TEMP_LOW            0x02
+#define LM92_ALARM_TEMP_CRIT   0x04
+#define LM92_TEMP_HIGH                 0x08
+#define LM92_TEMP_LOW                  0x10
+#define LM92_TEMP_CRIT                 0x20
+#define LM92_TEMP_HYST                 0x40
+#define LM92_TEMP_INPUT                        0x80
+
+/* -- SENSORS SYSCTL END -- */
+
+static ctl_table lm92_dir_table[] = {
+       {LM92_SYSCTL_TEMP, "temp", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &lm92_temp, NULL},
+       {LM92_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &lm92_alarms, NULL},
+       {0}
+};
+
+/* NOTE: all temperatures are degrees centigrade * 16 */
+typedef struct {
+       struct i2c_client client;
+       int sysctl_id;
+       unsigned long timestamp;
+       struct {
+               long high;
+               long low;
+               long crit;
+               long hyst;
+               long input;
+       } temp;
+       struct {
+               long low;
+               long high;
+               long crit;
+       } alarms;
+} lm92_t;
+
+/* this is needed for each client driver method */
+static struct i2c_driver lm92_driver;
+
+/* ensure exclusive access to chip and static variables */
+static DECLARE_MUTEX (mutex);
+
+/* addresses to scan */
+static unsigned short normal_i2c[] = { SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { 0x48, 0x4f, SENSORS_I2C_END };
+static unsigned int normal_isa[] = { SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+/* insmod parameters */
+SENSORS_INSMOD_1 (lm92);
+
+static inline int lm92_write8 (struct i2c_client *client,u8 reg,u8 value)
+{
+       return (i2c_smbus_write_byte_data (client,reg,value) < 0 ? -EIO : 0);
+}
+
+static inline int lm92_read16 (struct i2c_client *client,u8 reg,u16 *value)
+{
+       s32 tmp = i2c_smbus_read_word_data (client,reg);
+
+       if (tmp < 0) return (-EIO);
+
+       /* convert the data to little endian format */
+       *value = swab16((u16) tmp);
+
+       return (0);
+}
+
+static inline int lm92_write16 (struct i2c_client *client,u8 reg,u16 value)
+{
+       /* convert the data to big endian format */
+       if (i2c_smbus_write_word_data(client, reg, swab16(value)) < 0)
+               return -EIO;
+
+       return 0;
+}
+
+static int lm92_read (struct i2c_client *client)
+{
+       lm92_t *data = (lm92_t *) client->data;
+       u16 value[5];
+
+       if ((jiffies - data->timestamp) > HZ) {
+               if (lm92_read16 (client,LM92_REG_TEMPERATURE,value) < 0 ||
+                       lm92_read16 (client,LM92_REG_TRIP_HYSTERESIS,value + 1) < 0 ||
+                       lm92_read16 (client,LM92_REG_TRIP_CRITICAL,value + 2) < 0 ||
+                       lm92_read16 (client,LM92_REG_TRIP_LOW,value + 3) < 0 ||
+                       lm92_read16 (client,LM92_REG_TRIP_HIGH,value + 4) < 0)
+                       return (-EIO);
+
+               data->temp.input = (s16) value[0] >> 3;
+               data->temp.hyst = (s16) value[1] >> 3;
+               data->temp.crit = (s16) value[2] >> 3;
+               data->temp.low = (s16) value[3] >> 3;
+               data->temp.high = (s16) value[4] >> 3;
+
+               data->alarms.low = value[0] & 1;
+               data->alarms.high = (value[0] & 2) >> 1;
+               data->alarms.crit = (value[0] & 4) >> 2;
+
+               data->timestamp = jiffies;
+       }
+
+       return (0);
+}
+
+static int lm92_write (struct i2c_client *client)
+{
+       lm92_t *data = (lm92_t *) client->data;
+
+       LIMIT (data->temp.hyst);
+       LIMIT (data->temp.crit);
+       LIMIT (data->temp.low);
+       LIMIT (data->temp.high);
+
+       if (lm92_write16 (client,LM92_REG_TRIP_HYSTERESIS,((s16) data->temp.hyst << 3)) < 0 ||
+               lm92_write16 (client,LM92_REG_TRIP_CRITICAL,((s16) data->temp.crit << 3)) < 0 ||
+               lm92_write16 (client,LM92_REG_TRIP_LOW,((s16) data->temp.low << 3)) < 0 ||
+               lm92_write16 (client,LM92_REG_TRIP_HIGH,((s16) data->temp.high << 3)) < 0)
+               return (-EIO);
+
+       return (0);
+}
+
+static void lm92_temp (struct i2c_client *client,int operation,int ctl_name,int *nrels_mag,long *results)
+{
+       if (!down_interruptible (&mutex)) {
+               lm92_t *data = (lm92_t *) client->data;
+
+               if (operation == SENSORS_PROC_REAL_READ) {
+                       lm92_read (client);
+                       results[0] = NATIVE_TO_PROC (data->temp.input);
+                       results[1] = NATIVE_TO_PROC (data->temp.high);
+                       results[2] = NATIVE_TO_PROC (data->temp.low);
+                       results[3] = NATIVE_TO_PROC (data->temp.crit);
+                       results[4] = NATIVE_TO_PROC (data->temp.hyst);
+                       *nrels_mag = 5;
+               } else if (operation == SENSORS_PROC_REAL_WRITE && *nrels_mag == 4) {
+                       data->temp.high = PROC_TO_NATIVE (results[0]);
+                       data->temp.low = PROC_TO_NATIVE (results[1]);
+                       data->temp.crit = PROC_TO_NATIVE (results[2]);
+                       data->temp.hyst = PROC_TO_NATIVE (results[3]);
+                       lm92_write (client);
+               } else if (operation == SENSORS_PROC_REAL_INFO) {
+                       *nrels_mag = 4;
+               }
+
+               up (&mutex);
+       }
+}
+
+static void lm92_alarms (struct i2c_client *client,int operation,int ctl_name,int *nrels_mag,long *results)
+{
+       if (!down_interruptible (&mutex)) {
+               lm92_t *data = (lm92_t *) client->data;
+
+               if (operation == SENSORS_PROC_REAL_READ) {
+                       lm92_read (client);
+                       results[0] = data->alarms.high || (data->alarms.low << 1) || (data->alarms.crit << 2);
+                       *nrels_mag = 1;
+               } else if (operation == SENSORS_PROC_REAL_INFO) {
+                       *nrels_mag = 0;
+               }
+
+               up (&mutex);
+       }
+}
+
+static int max6635_check(struct i2c_client *client)
+{
+       int i;
+       u16 temp_low, temp_high, temp_hyst, temp_crit;
+       u8 conf;
+
+       temp_low = i2c_smbus_read_word_data(client, LM92_REG_TRIP_LOW);
+       temp_high = i2c_smbus_read_word_data(client, LM92_REG_TRIP_HIGH);
+       temp_hyst = i2c_smbus_read_word_data(client, LM92_REG_TRIP_HYSTERESIS);
+       temp_crit = i2c_smbus_read_word_data(client, LM92_REG_TRIP_CRITICAL);
+       
+       if ((temp_low & 0x7f00) || (temp_high & 0x7f00)
+        || (temp_hyst & 0x7f00) || (temp_crit & 0x7f00))
+               return 0;
+
+       conf = i2c_smbus_read_byte_data(client, LM92_REG_CONFIGURATION);
+
+       for (i=0; i<128; i+=16) {
+               if (temp_low != i2c_smbus_read_word_data(client, LM92_REG_TRIP_LOW + i)
+                || temp_high != i2c_smbus_read_word_data(client, LM92_REG_TRIP_HIGH + i)
+                || temp_hyst != i2c_smbus_read_word_data(client, LM92_REG_TRIP_HYSTERESIS + i)
+                || temp_crit != i2c_smbus_read_word_data(client, LM92_REG_TRIP_CRITICAL + i)
+                || conf != i2c_smbus_read_byte_data(client, LM92_REG_CONFIGURATION + i))
+                       return 0;
+       }
+       
+       return 1;
+}
+
+static int lm92_init_client (struct i2c_client *client)
+{
+       lm92_t *data = (lm92_t *) client->data;
+       u8 value = 0;
+       int result;
+
+       /* force reads to query the chip */
+       data->timestamp = 0;
+
+       /* setup the configuration register */
+
+#ifdef ENABLE_FAULT_QUEUE
+       value |= 0x10;
+#endif /* #ifdef ENABLE_FAULT_QUEUE */
+
+       if (lm92_write8 (client,LM92_REG_CONFIGURATION,value) < 0)
+               return (-ENODEV);
+
+       /* set default alarm trigger values */
+
+       data->temp.high = CELSIUS (64);
+       data->temp.low = CELSIUS (10);
+       data->temp.crit = CELSIUS (80);
+       data->temp.hyst = CELSIUS (2);
+
+       if ((result = lm92_write (client)) < 0)
+               return (result);
+
+       /* read everything once so that our cached data is updated */
+
+       if ((result = lm92_read (client)) < 0)
+               return (result);
+
+       return (0);
+}
+
+static int lm92_detect (struct i2c_adapter *adapter,int address,unsigned short flags,int kind)
+{
+       static int id = 0;
+       struct i2c_client *client;
+       lm92_t *data;
+       int result;
+       u16 manufacturer;
+
+       if (!i2c_check_functionality (adapter,I2C_FUNC_SMBUS_BYTE_DATA))
+               return (-ENODEV);
+
+       if (!(data = kmalloc(sizeof(lm92_t), GFP_KERNEL)))
+               return (-ENOMEM);
+
+       client = &data->client;
+       client->addr = address;
+       client->data = data;
+       client->adapter = adapter;
+       client->driver = &lm92_driver;
+       client->flags = 0;
+       strcpy (client->name,lm92_driver.name);
+
+       if (down_interruptible (&mutex)) {
+               result = -ERESTARTSYS;
+               goto ERROR1;
+       }
+
+       if (kind < 0) {
+               /* Is it an lm92? */
+               if (address < 0x4c
+                && (lm92_read16(client,LM92_REG_MANUFACTURER,&manufacturer) < 0
+                 || manufacturer != LM92_MANUFACTURER_ID)) {
+                       /* Is it a MAX6635/MAX6635/MAX6635? */
+                       if (!max6635_check(client)) {
+                               result = -ENODEV;
+                               goto ERROR2;
+                       }
+               }
+       }
+
+       if ((result = i2c_attach_client (client))) {
+               goto ERROR2;
+       }
+
+       if ((result = i2c_register_entry (client,client->name,lm92_dir_table)) < 0) {
+               goto ERROR3;
+       }
+       data->sysctl_id = result;
+
+       if ((result = lm92_init_client (client)) < 0) {
+               goto ERROR4;
+       }
+
+       client->id = id++;
+
+       up (&mutex);
+
+       return (0);
+
+ERROR4:
+       i2c_deregister_entry(data->sysctl_id);
+ERROR3:
+       i2c_detach_client(client);
+ERROR2:
+       up(&mutex);
+ERROR1:
+       kfree(data);
+       return result;
+}
+
+static int lm92_attach_adapter (struct i2c_adapter *adapter)
+{
+       return i2c_detect (adapter,&addr_data,lm92_detect);
+}
+
+static int lm92_detach_client (struct i2c_client *client)
+{
+       int result;
+
+       i2c_deregister_entry (((lm92_t *) (client->data))->sysctl_id);
+
+       if ((result = i2c_detach_client (client)))
+               return (result);
+
+       kfree(client->data);
+
+       return (0);
+}
+
+
+static struct i2c_driver lm92_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "lm92",
+       .id             = I2C_DRIVERID_LM92,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = lm92_attach_adapter,
+       .detach_client  = lm92_detach_client,
+};
+
+static int __init sm_lm92_init(void)
+{
+       printk ("lm92.o version %s (%s)\n",LM_VERSION,LM_DATE);
+       return i2c_add_driver(&lm92_driver);
+}
+
+
+static void __exit sm_lm92_exit(void)
+{
+       i2c_del_driver(&lm92_driver);
+}
+
+
+
+MODULE_AUTHOR ("Abraham van der Merwe <abraham@2d3d.co.za>");
+MODULE_DESCRIPTION ("Linux support for LM92 Temperature Sensor");
+
+MODULE_LICENSE ("GPL");
+
+module_init(sm_lm92_init);
+module_exit(sm_lm92_exit);
+
--- linux-old/drivers/sensors/matorb.c  Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/matorb.c      Mon Dec 13 20:18:49 2004
@@ -0,0 +1,286 @@
+/*
+    matorb.c - Part of lm_sensors, Linux kernel modules for hardware
+             monitoring
+    Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl>
+    and Philip Edelbrock <phil@netroedge.com>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+
+#define DEBUG 1
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+MODULE_LICENSE("GPL");
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = { 0x2E, SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { SENSORS_I2C_END };
+static unsigned int normal_isa[] = { SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+/* Insmod parameters */
+SENSORS_INSMOD_1(matorb);
+
+/* Many MATORB constants specified below */
+
+
+/* Each client has this additional data */
+struct matorb_data {
+       struct i2c_client client;
+       int sysctl_id;
+
+       struct semaphore update_lock;
+       char valid;             /* !=0 if following fields are valid */
+       unsigned long last_updated;     /* In jiffies */
+
+};
+
+static int matorb_attach_adapter(struct i2c_adapter *adapter);
+static int matorb_detect(struct i2c_adapter *adapter, int address,
+                        unsigned short flags, int kind);
+static void matorb_init_client(struct i2c_client *client);
+static int matorb_detach_client(struct i2c_client *client);
+
+static int matorb_write_value(struct i2c_client *client, u8 reg,
+                             u16 value);
+static void matorb_disp(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void matorb_update_client(struct i2c_client *client);
+
+
+/* This is the driver that will be inserted */
+static struct i2c_driver matorb_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "Matrix Orbital LCD driver",
+       .id             = I2C_DRIVERID_MATORB,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = matorb_attach_adapter,
+       .detach_client  = matorb_detach_client,
+};
+
+/* -- SENSORS SYSCTL START -- */
+#define MATORB_SYSCTL_DISP 1000
+/* -- SENSORS SYSCTL END -- */
+
+/* These files are created for each detected MATORB. This is just a template;
+   though at first sight, you might think we could use a statically
+   allocated list, we need some way to get back to the parent - which
+   is done through one of the 'extra' fields which are initialized
+   when a new copy is allocated. */
+static ctl_table matorb_dir_table_template[] = {
+       {MATORB_SYSCTL_DISP, "disp", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &matorb_disp},
+       {0}
+};
+
+static int matorb_id = 0;
+
+static int matorb_attach_adapter(struct i2c_adapter *adapter)
+{
+       return i2c_detect(adapter, &addr_data, matorb_detect);
+}
+
+/* This function is called by i2c_detect */
+int matorb_detect(struct i2c_adapter *adapter, int address,
+                 unsigned short flags, int kind)
+{
+       int i, cur;
+       struct i2c_client *new_client;
+       struct matorb_data *data;
+       int err = 0;
+       const char *type_name = "matorb";
+       const char *client_name = "matorb";
+
+       /* Make sure we aren't probing the ISA bus!! This is just a safety check
+          at this moment; i2c_detect really won't call us. */
+#ifdef DEBUG
+       if (i2c_is_isa_adapter(adapter)) {
+               printk
+                   ("matorb.o: matorb_detect called for an ISA bus adapter?!?\n");
+               return 0;
+       }
+#endif
+
+       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WRITE_BYTE |
+                                    I2C_FUNC_SMBUS_WRITE_BYTE_DATA))
+                   goto ERROR0;
+
+
+       /* OK. For now, we presume we have a valid client. We now create the
+          client structure, even though we cannot fill it completely yet.
+          But it allows us to access matorb_{read,write}_value. */
+       if (!(data = kmalloc(sizeof(struct matorb_data), GFP_KERNEL))) {
+               err = -ENOMEM;
+               goto ERROR0;
+       }
+
+       new_client = &data->client;
+       new_client->addr = address;
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &matorb_driver;
+       new_client->flags = 0;
+
+       /* Now, we do the remaining detection. It is lousy. */
+       cur = i2c_smbus_write_byte_data(new_client, 0x0FE, 0x58);       /* clear screen */
+
+       printk("matorb.o: debug detect 0x%X\n", cur);
+
+       /* Fill in the remaining client fields and put it into the global list */
+       strcpy(new_client->name, client_name);
+
+       new_client->id = matorb_id++;
+       data->valid = 0;
+       init_MUTEX(&data->update_lock);
+
+       /* Tell the I2C layer a new client has arrived */
+       if ((err = i2c_attach_client(new_client)))
+               goto ERROR3;
+
+       /* Register a new directory entry with module sensors */
+       if ((i = i2c_register_entry(new_client, type_name,
+                                       matorb_dir_table_template)) < 0) {
+               err = i;
+               goto ERROR4;
+       }
+       data->sysctl_id = i;
+
+       matorb_init_client(new_client);
+       return 0;
+
+/* OK, this is not exactly good programming practice, usually. But it is
+   very code-efficient in this case. */
+
+      ERROR4:
+       i2c_detach_client(new_client);
+      ERROR3:
+       kfree(data);
+      ERROR0:
+       return err;
+}
+
+static int matorb_detach_client(struct i2c_client *client)
+{
+       int err;
+
+       i2c_deregister_entry(((struct matorb_data *) (client->data))->
+                                sysctl_id);
+
+       if ((err = i2c_detach_client(client))) {
+               printk
+                   ("matorb.o: Client deregistration failed, client not detached.\n");
+               return err;
+       }
+
+       kfree(client->data);
+
+       return 0;
+}
+
+
+#if 0
+/* All registers are word-sized, except for the configuration register.
+   MATORB uses a high-byte first convention, which is exactly opposite to
+   the usual practice. */
+static int matorb_read_value(struct i2c_client *client, u8 reg)
+{
+       return -1;              /* Doesn't support reads */
+}
+#endif
+
+/* All registers are word-sized, except for the configuration register.
+   MATORB uses a high-byte first convention, which is exactly opposite to
+   the usual practice. */
+static int matorb_write_value(struct i2c_client *client, u8 reg, u16 value)
+{
+       if (reg == 0) {
+               return i2c_smbus_write_byte(client, value);
+       } else {
+               return i2c_smbus_write_byte_data(client, reg, value);
+       }
+}
+
+static void matorb_init_client(struct i2c_client *client)
+{
+       /* Initialize the MATORB chip */
+}
+
+static void matorb_update_client(struct i2c_client *client)
+{
+       struct matorb_data *data = client->data;
+
+       down(&data->update_lock);
+
+       if ((jiffies - data->last_updated > HZ + HZ / 2) ||
+           (jiffies < data->last_updated) || !data->valid) {
+
+#ifdef DEBUG
+               printk("Starting matorb update\n");
+#endif
+
+/* nothing yet */
+               data->last_updated = jiffies;
+               data->valid = 1;
+       }
+
+       up(&data->update_lock);
+}
+
+
+void matorb_disp(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       int i;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               matorb_update_client(client);
+               results[0] = 0;
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               for (i = 1; i <= *nrels_mag; i++) {
+                       matorb_write_value(client, 0, results[i - 1]);
+               }
+       }
+}
+
+static int __init sm_matorb_init(void)
+{
+       printk("matorb.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       return i2c_add_driver(&matorb_driver);
+}
+
+static void __exit sm_matorb_exit(void)
+{
+       i2c_del_driver(&matorb_driver);
+}
+
+
+
+MODULE_AUTHOR
+    ("Frodo Looijaard <frodol@dds.nl> and Philip Edelbrock <phil@netroedge.com>");
+MODULE_DESCRIPTION("MATORB driver");
+
+module_init(sm_matorb_init);
+module_exit(sm_matorb_exit);
--- linux-old/drivers/sensors/max6650.c Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/max6650.c     Mon Dec 13 20:18:50 2004
@@ -0,0 +1,545 @@
+/*
+ * max6650.c - Part of lm_sensors, Linux kernel modules for hardware
+ *             monitoring. 
+ * 
+ * Author: John Morris <john.morris@spirentcom.com>
+ *
+ * Copyright (c) 2003 Spirent Communications
+ *
+ * This module has only been tested with the MAX6651 chip. It should
+ * work with the MAX6650 also, though with reduced functionality. It
+ * does not yet distinguish max6650 and max6651 chips.
+ * 
+ * Tha datasheet was last seen at: 
+ *
+ *        http://pdfserv.maxim-ic.com/en/ds/MAX6650-MAX6651.pdf
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/i2c-id.h>
+#include <linux/init.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+#ifndef I2C_DRIVERID_MAX6650
+#define I2C_DRIVERID_MAX6650   1044
+#endif
+
+/*
+ * Addresses to scan. There are four disjoint possibilities, by pin config.
+ */
+
+static unsigned short normal_i2c[] = {0x1b, 0x1f, 0x48, 0x4b, SENSORS_I2C_END};
+static unsigned short normal_i2c_range[] = { SENSORS_I2C_END };
+static unsigned int normal_isa[] = { SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+/*
+ * Insmod parameters
+ */
+
+SENSORS_INSMOD_1(max6650);
+
+/* 
+ * MAX 6650/6651 registers
+ */
+
+#define MAX6650_REG_SPEED       0x00
+#define MAX6650_REG_CONFIG      0x02
+#define MAX6650_REG_GPIO_DEF    0x04
+#define MAX6650_REG_DAC         0x06
+#define MAX6650_REG_ALARM_EN    0x08
+#define MAX6650_REG_ALARM       0x0A
+#define MAX6650_REG_TACH0       0x0C
+#define MAX6650_REG_TACH1       0x0E
+#define MAX6650_REG_TACH2       0x10
+#define MAX6650_REG_TACH3       0x12
+#define MAX6650_REG_GPIO_STAT   0x14
+#define MAX6650_REG_COUNT       0x16
+
+/*
+ * Config register bits
+ */
+ 
+#define MAX6650_CFG_MODE_MASK           0x30
+#define MAX6650_CFG_MODE_ON             0x00
+#define MAX6650_CFG_MODE_OFF            0x10
+#define MAX6650_CFG_MODE_CLOSED_LOOP    0x20
+#define MAX6650_CFG_MODE_OPEN_LOOP      0x30
+
+static const u8 tach_reg[] = 
+{
+    MAX6650_REG_TACH0, MAX6650_REG_TACH1, 
+    MAX6650_REG_TACH2, MAX6650_REG_TACH3 
+};
+
+#define MAX6650_INT_CLK 254000  /* Default clock speed - 254 kHz */
+
+/*
+ * Functions declaration
+ */
+
+static void max6650_fan (struct i2c_client *client, int operation, int
+       ctl_name, int *nrels_mag, long *results);
+static void max6650_speed (struct i2c_client *client, int operation, int
+       ctl_name, int *nrels_mag, long *results);
+static void max6650_xdump (struct i2c_client *client, int operation, int
+       ctl_name, int *nrels_mag, long *results);
+static int max6650_detect(struct i2c_adapter *adapter, int address, unsigned
+       short flags, int kind);
+static int max6650_attach_adapter(struct i2c_adapter *adapter);
+static int max6650_detach_client(struct i2c_client *client);
+static void max6650_init_client(struct i2c_client *client);
+static int max6650_read(struct i2c_client *client, u8 reg);
+
+/*
+ * Driver data (common to all clients)
+ */
+
+
+static struct i2c_driver max6650_driver = {
+    .owner          = THIS_MODULE,
+    .name           = "MAX6650/1 sensor driver",
+    .id             = I2C_DRIVERID_MAX6650,
+    .flags          = I2C_DF_NOTIFY,
+    .attach_adapter = max6650_attach_adapter,
+    .detach_client  = max6650_detach_client
+};
+
+/*
+ * Client data (each client gets its own)
+ */
+
+struct max6650_data
+{
+       struct i2c_client client;
+    int sysctl_id;
+    struct semaphore update_lock;
+    char valid;                 /* zero until following fields are valid */
+    unsigned long last_updated; /* in jiffies */
+
+    /* register values */
+       
+    u8 speed;
+    u8 config;
+    u8 tach[4];
+    u8 count;
+};
+
+/*
+ * Proc entries
+ * These files are created for each detected max6650.
+ */
+
+/* -- SENSORS SYSCTL START -- */
+
+#define MAX6650_SYSCTL_FAN1     1101
+#define MAX6650_SYSCTL_FAN2     1102
+#define MAX6650_SYSCTL_FAN3     1103
+#define MAX6650_SYSCTL_FAN4     1104
+#define MAX6650_SYSCTL_SPEED    1105
+#define MAX6650_SYSCTL_XDUMP    1106
+
+
+/* -- SENSORS SYSCTL END -- */
+
+
+static ctl_table max6650_dir_table_template[] =
+{
+    {MAX6650_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL,
+                &i2c_proc_real, &i2c_sysctl_real, NULL, &max6650_fan},
+    {MAX6650_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL,
+                &i2c_proc_real, &i2c_sysctl_real, NULL, &max6650_fan},
+    {MAX6650_SYSCTL_FAN3, "fan3", NULL, 0, 0644, NULL,
+                &i2c_proc_real, &i2c_sysctl_real, NULL, &max6650_fan},
+    {MAX6650_SYSCTL_FAN4, "fan4", NULL, 0, 0644, NULL,
+                &i2c_proc_real, &i2c_sysctl_real, NULL, &max6650_fan},
+    {MAX6650_SYSCTL_SPEED, "speed", NULL, 0, 0644, NULL,
+                &i2c_proc_real, &i2c_sysctl_real, NULL, &max6650_speed},
+    {MAX6650_SYSCTL_XDUMP, "xdump", NULL, 0, 0644, NULL,
+                &i2c_proc_real, &i2c_sysctl_real, NULL, &max6650_xdump},
+    {0}
+};
+
+/*
+ * Internal variables
+ */
+
+static int max6650_id = 0;
+
+/*
+ * Real code
+ */
+
+static int max6650_attach_adapter(struct i2c_adapter *adapter)
+{
+    return i2c_detect(adapter, &addr_data, max6650_detect);
+}
+
+/*
+ * The following function does more than just detection. If detection
+ * succeeds, it also registers the new chip.
+ */
+
+static int max6650_detect(struct i2c_adapter *adapter, int address, unsigned
+       short flags, int kind)
+{
+    struct i2c_client *new_client;
+    struct max6650_data *data;
+    int err = 0;
+    const char *type_name = "";
+    const char *client_name = "";
+
+#ifdef DEBUG
+    if (i2c_is_isa_adapter(adapter)) {
+        printk("max6650.o: Called for an ISA bus adapter, aborting.\n");
+        return 0;
+    }
+#endif
+
+    if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
+#ifdef DEBUG
+        printk("max6650.o: I2C bus doesn't support byte read mode, skipping.\n");
+#endif
+        return 0;
+    }
+
+    if (!(data = kmalloc(sizeof(struct max6650_data), GFP_KERNEL))) {
+        printk("max6650.o: Out of memory in max6650_detect (new_client).\n");
+        return -ENOMEM;
+    }
+
+    /*
+     * The common I2C client data is placed right before the
+     * max6650-specific data. The max6650-specific data is pointed to by the
+        * data field from the I2C client data.
+     */
+
+       new_client = &data->client;
+    new_client->addr = address;
+    new_client->data = data;
+    new_client->adapter = adapter;
+    new_client->driver = &max6650_driver;
+    new_client->flags = 0;
+
+    /*
+     * 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 latter.
+     */
+
+    if (kind < 0) {     /* detection */
+        if (
+            (max6650_read(new_client, MAX6650_REG_CONFIG) & 0xC0) ||
+            (max6650_read(new_client, MAX6650_REG_GPIO_STAT) & 0xE0) ||
+            (max6650_read(new_client, MAX6650_REG_ALARM_EN) & 0xE0) ||
+            (max6650_read(new_client, MAX6650_REG_ALARM) & 0xE0) ||
+            (max6650_read(new_client, MAX6650_REG_COUNT) & 0xFC) 
+        )
+        {
+#ifdef DEBUG
+            printk("max6650.o: max6650 detection failed at 0x%02x.\n",
+                                                                    address);
+#endif
+            goto ERROR1;
+        }
+    }
+
+    if (kind <= 0) { /* identification */
+        kind = max6650;
+    }
+
+    if (kind <= 0) {    /* identification failed */
+        printk("max6650.o: Unsupported chip.\n");
+        goto ERROR1;
+    }
+
+    if (kind == max6650) {
+        type_name = "max6650";
+        client_name = "max6650 chip";
+    } else {
+        printk("max6650.o: Unknown kind %d.\n", kind);
+        goto ERROR1;
+    }
+       
+    /*
+     * OK, we got a valid chip so we can fill in the remaining client
+     * fields.
+     */
+
+    strcpy(new_client->name, client_name);
+    new_client->id = max6650_id++;
+    data->valid = 0;
+    init_MUTEX(&data->update_lock);
+
+    /*
+     * Tell the I2C layer a new client has arrived.
+     */
+
+    if ((err = i2c_attach_client(new_client))) {
+#ifdef DEBUG
+        printk("max6650.o: Failed attaching client.\n");
+#endif
+        goto ERROR1;
+    }
+
+    /*
+     * Register a new directory entry.
+     */
+    if ((err = i2c_register_entry(new_client, type_name,
+                                    max6650_dir_table_template)) < 0) {
+#ifdef DEBUG
+        printk("max6650.o: Failed registering directory entry.\n");
+#endif
+        goto ERROR2;
+    }
+    data->sysctl_id = err;
+
+    /*
+     * Initialize the max6650 chip
+     */
+    max6650_init_client(new_client);
+    return 0;
+
+ERROR2:
+    i2c_detach_client(new_client);
+ERROR1:
+    kfree(data);
+    return err;
+}
+
+static void max6650_init_client(struct i2c_client *client)
+{
+    /* Nothing to do here - assume the BIOS has initialized the chip */
+}
+
+static int max6650_detach_client(struct i2c_client *client)
+{
+    int err;
+
+    i2c_deregister_entry(((struct max6650_data *) (client->data))->sysctl_id);
+    if ((err = i2c_detach_client(client))) {
+        printk("max6650.o: Client deregistration failed, "
+                                        "client not detached.\n");
+        return err;
+    }
+
+    kfree(client->data);
+    return 0;
+}
+
+static int max6650_read(struct i2c_client *client, u8 reg)
+{
+    return i2c_smbus_read_byte_data(client, reg);
+}
+
+static int max6650_write(struct i2c_client *client, u8 reg, u8 value)
+{
+    return i2c_smbus_write_byte_data(client, reg, value);
+}
+
+static void max6650_update_client(struct i2c_client *client)
+{
+    int i;
+    struct max6650_data *data = client->data;
+
+    down(&data->update_lock);
+    
+    if ((jiffies - data->last_updated > HZ) ||
+        (jiffies < data->last_updated) || !data->valid) {
+#ifdef DEBUG
+        printk("max6650.o: Updating max6650 data.\n");
+#endif
+        data->speed  = max6650_read (client, MAX6650_REG_SPEED);
+        data->config = max6650_read (client, MAX6650_REG_CONFIG);
+        for (i = 0; i < 4; i++) {
+            data->tach[i] = max6650_read(client, tach_reg[i]);
+        }
+        data->count = max6650_read (client, MAX6650_REG_COUNT);
+        data->last_updated = jiffies;
+        data->valid = 1;
+    }
+    up(&data->update_lock);
+}
+
+static void max6650_fan (struct i2c_client *client, int operation, int
+       ctl_name, int *nrels_mag, long *results)
+{
+    int index = ctl_name - MAX6650_SYSCTL_FAN1;
+    struct max6650_data *data = client->data;
+    int tcount;         /* Tachometer count time, 0.25 second units */
+
+    if (operation == SENSORS_PROC_REAL_INFO) {
+       *nrels_mag = 0;
+    } else if (operation == SENSORS_PROC_REAL_READ) {
+        max6650_update_client(client);
+
+        /*
+         * Calculation details:
+         *
+         * Each tachometer counts over an interval given by the "count"
+         * register (0.25, 0.5, 1 or 2 seconds). This module assumes
+         * that the fans produce two pulses per revolution (this seems
+         * to be the most common).
+         */
+         
+        tcount = 1 << data->count;         /* 0.25 second units */
+        results[0] = (data->tach[index] * 240) / tcount;    /* counts per min */
+        results[0] /= 2;                   /* Assume two counts per rev */
+        *nrels_mag = 1;
+    }
+}
+
+/*
+ * Set the fan speed to the specified RPM (or read back the RPM setting).
+ *
+ * The MAX6650/1 will automatically control fan speed when in closed loop
+ * mode.
+ *
+ * Assumptions:
+ *
+ * 1) The MAX6650/1 is running from its internal 254kHz clock (perhaps
+ *    this should be made a module parameter).
+ *
+ * 2) The prescaler (low three bits of the config register) has already
+ *    been set to an appropriate value.
+ *
+ * The relevant equations are given on pages 21 and 22 of the datasheet.
+ *
+ * From the datasheet, the relevant equation when in regulation is:
+ *
+ *    [fCLK / (128 x (KTACH + 1))] = 2 x FanSpeed / KSCALE
+ *
+ * where:
+ *
+ *    fCLK is the oscillator frequency (either the 254kHz internal 
+ *         oscillator or the externally applied clock)
+ *
+ *    KTACH is the value in the speed register
+ *
+ *    FanSpeed is the speed of the fan in rps
+ *
+ *    KSCALE is the prescaler value (1, 2, 4, 8, or 16)
+ *
+ * When reading, we need to solve for FanSpeed. When writing, we need to
+ * solve for KTACH.
+ *
+ * Note: this tachometer is completely separate from the tachometers
+ * used to measure the fan speeds. Only one fan's speed (fan1) is
+ * controlled.
+ */
+
+static void max6650_speed (struct i2c_client *client, int operation, int
+                               ctl_name, int *nrels_mag, long *results)
+{
+    struct max6650_data *data = client->data;
+    int kscale, ktach, fclk, rpm;
+    
+    if (operation == SENSORS_PROC_REAL_INFO) {
+        *nrels_mag = 0;
+    } else if (operation == SENSORS_PROC_REAL_READ) {
+        /*
+         * Use the datasheet equation:
+         *
+         *    FanSpeed = KSCALE x fCLK / [256 x (KTACH + 1)]
+         *
+         * then multiply by 60 to give rpm.
+         */
+
+        max6650_update_client(client);
+
+        kscale = 1 << (data->config & 7);
+        ktach  = data->speed;
+        fclk   = MAX6650_INT_CLK;
+        rpm    = 60 * kscale * fclk / (256 * (ktach + 1));
+
+        results[0] = rpm;
+        *nrels_mag = 1;
+    } else if (operation == SENSORS_PROC_REAL_WRITE && *nrels_mag >= 1) {
+        /*
+         * Divide the required speed by 60 to get from rpm to rps, then
+         * use the datasheet equation:
+         *
+         *     KTACH = [(fCLK x KSCALE) / (256 x FanSpeed)] - 1
+         */
+
+        max6650_update_client(client);
+
+        rpm    = results[0];
+        kscale = 1 << (data->config & 7);
+        fclk   = MAX6650_INT_CLK;
+        ktach  = ((fclk * kscale) / (256 * rpm / 60)) - 1;
+
+        data->speed  = ktach;
+        data->config = (data->config & ~MAX6650_CFG_MODE_MASK) | 
+                                            MAX6650_CFG_MODE_CLOSED_LOOP;
+        max6650_write (client, MAX6650_REG_CONFIG, data->config);
+        max6650_write (client, MAX6650_REG_SPEED,  data->speed);
+    }
+}
+
+/*
+ * Debug - dump all registers except the tach counts.
+ */
+                                 
+static void max6650_xdump (struct i2c_client *client, int operation, int
+       ctl_name, int *nrels_mag, long *results)
+{
+    if (operation == SENSORS_PROC_REAL_INFO) {
+        *nrels_mag = 0;
+    } else if (operation == SENSORS_PROC_REAL_READ) {
+        results[0] = max6650_read (client, MAX6650_REG_SPEED);
+        results[1] = max6650_read (client, MAX6650_REG_CONFIG);
+        results[2] = max6650_read (client, MAX6650_REG_GPIO_DEF);
+        results[3] = max6650_read (client, MAX6650_REG_DAC);
+        results[4] = max6650_read (client, MAX6650_REG_ALARM_EN);
+        results[5] = max6650_read (client, MAX6650_REG_ALARM);
+        results[6] = max6650_read (client, MAX6650_REG_GPIO_STAT);
+        results[7] = max6650_read (client, MAX6650_REG_COUNT);
+        *nrels_mag = 8;
+    }
+}
+
+static int __init sm_max6650_init(void)
+{
+    printk(KERN_INFO "max6650.o version %s (%s)\n", LM_VERSION, LM_DATE);
+    return i2c_add_driver(&max6650_driver);
+}
+
+static void __exit sm_max6650_exit(void)
+{
+    i2c_del_driver(&max6650_driver);
+}
+
+MODULE_AUTHOR("john.morris@spirentcom.com");
+MODULE_DESCRIPTION("max6650 sensor driver");
+MODULE_LICENSE("GPL");
+
+module_init(sm_max6650_init);
+module_exit(sm_max6650_exit);
--- linux-old/drivers/sensors/maxilife.c        Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/maxilife.c    Mon Dec 13 20:18:50 2004
@@ -0,0 +1,1387 @@
+/*
+    maxilife.c - Part of lm_sensors, Linux kernel modules for hardware
+                 monitoring
+    Copyright (c) 1999-2000 Fons Rademakers <Fons.Rademakers@cern.ch> 
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/* The is the driver for the HP MaxiLife Health monitoring system
+   as used in the line of HP Kayak Workstation PC's.
+   
+   The driver supports the following MaxiLife firmware versions:
+   
+   0) HP KAYAK XU/XAs (Dual Pentium II Slot 1, Deschutes/Klamath)
+   1) HP KAYAK XU (Dual Xeon [Slot 2] 400/450 Mhz)
+   2) HP KAYAK XA (Pentium II Slot 1, monoprocessor)
+   
+   Currently firmware auto detection is not implemented. To use the
+   driver load it with the correct option for you Kayak. For example:
+   
+   insmod maxilife.o maxi_version=0 | 1 | 2
+   
+   maxi_version=0 is the default
+   
+   This version of MaxiLife is called MaxiLife'98 and has been
+   succeeded by MaxiLife'99, see below.
+   
+   The new version of the driver also supports MaxiLife NBA (New BIOS
+   Architecture). This new MaxiLife controller provides a much cleaner
+   machine independent abstraction layer to the MaxiLife controller.
+   Instead of accessing directly registers (different for each revision)
+   one now accesses the sensors via unique mailbox tokens that do not
+   change between revisions. Also the quantities are already in physical
+   units (degrees, rpms, voltages, etc.) and don't need special conversion
+   formulas. This new MaxiLife is available on the new 2000 machines,
+   like the Kayak XU800 and XM600. This hardware is also autodetected.
+*/
+
+static const char *version_str = "2.00 29/2/2000 Fons Rademakers";
+
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+MODULE_LICENSE("GPL");
+
+#undef AUTODETECT              /* try to autodetect MaxiLife version */
+/*#define AUTODETECT*/
+#define NOWRITE                        /* don't allow writing to MaxiLife registers */
+
+#ifdef AUTODETECT
+#include <linux/vmalloc.h>
+#include <linux/ctype.h>
+#endif
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = { SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { 0x10, 0x14, SENSORS_I2C_END };
+static unsigned int normal_isa[] = { SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+/* Insmod parameters */
+SENSORS_INSMOD_1(maxilife);
+
+/* Macro definitions */
+#define LOW(MyWord) ((u8) (MyWord))
+#define HIGH(MyWord) ((u8) (((u16)(MyWord) >> 8) & 0xFF))
+
+/*----------------- MaxiLife'98 registers and conversion formulas ------------*/
+#define MAXI_REG_TEMP(nr)      (0x60 + (nr))
+
+#define MAXI_REG_FAN(nr)       (0x65 + (nr))
+#define MAXI_REG_FAN_MIN(nr)   ((nr)==0 ? 0xb3 : (nr)==1 ? 0xb3 : 0xab)
+#define MAXI_REG_FAN_MINAS(nr) ((nr)==0 ? 0xb3 : (nr)==1 ? 0xab : 0xb3)
+#define MAXI_REG_FAN_SPEED(nr) ((nr)==0 ? 0xe4 : (nr)==1 ? 0xe5 : 0xe9)
+
+#define MAXI_REG_PLL           0xb9
+#define MAXI_REG_PLL_MIN       0xba
+#define MAXI_REG_PLL_MAX       0xbb
+
+#define MAXI_REG_VID(nr)       ((nr)==0 ? 0xd1 : (nr)==1 ? 0xd9 : \
+                                (nr)==2 ? 0xd4 : 0xc5)
+#define MAXI_REG_VID_MIN(nr)   MAXI_REG_VID(nr)+1
+#define MAXI_REG_VID_MAX(nr)   MAXI_REG_VID(nr)+2
+
+#define MAXI_REG_DIAG_RT1      0x2c
+#define MAXI_REG_DIAG_RT2      0x2d
+
+#define MAXI_REG_BIOS_CTRL     0x2a
+
+/* Conversions. Rounding and limit checking is only done on the TO_REG
+   variants. Note that you should be a bit careful with which arguments
+   these macros are called: arguments may be evaluated more than once.
+   Fixing this is just not worth it. */
+
+                              /* 0xfe: fan off, 0xff: stopped (alarm) */
+                              /* 19531 / val * 60 == 1171860 / val */
+#define FAN_FROM_REG(val)      ((val)==0xfe ? 0 : (val)==0xff ? -1 : \
+                                (val)==0x00 ? -1 : (1171860 / (val)))
+
+static inline u8 FAN_TO_REG(long rpm)
+{
+       if (rpm == 0)
+               return 255;
+       rpm = SENSORS_LIMIT(rpm, 1, 1000000);
+       return SENSORS_LIMIT((1171860 + rpm / 2) / (rpm), 1, 254);
+}
+
+#define TEMP_FROM_REG(val)     ((val) * 5)
+#define TEMP_TO_REG(val)       (SENSORS_LIMIT((val+2) / 5),0,0xff)
+#define PLL_FROM_REG(val)      (((val) * 1000) / 32)
+#define PLL_TO_REG(val)        (SENSORS_LIMIT((((val) * 32 + 500) / 1000),\
+                                              0,0xff))
+#define VID_FROM_REG(val)      ((val) ? (((val) * 27390) / 256) + 3208 : 0)
+#define VID_TO_REG(val)        (SENSORS_LIMIT((((val) - 3208) * 256) / 27390, \
+                                              0,255))
+#define ALARMS_FROM_REG(val)   (val)
+
+/*----------------- MaxiLife'99 mailbox and token definitions ----------------*/
+/* MaxiLife mailbox data register map */
+#define MAXI_REG_MBX_STATUS    0x5a
+#define MAXI_REG_MBX_CMD       0x5b
+#define MAXI_REG_MBX_TOKEN_H   0x5c
+#define MAXI_REG_MBX_TOKEN_L   0x5d
+#define MAXI_REG_MBX_DATA      0x60
+
+/* Mailbox status register definition */
+#define MAXI_STAT_IDLE         0xff
+#define MAXI_STAT_OK           0x00
+#define MAXI_STAT_BUSY         0x0b
+/* other values not used */
+
+/* Mailbox command register opcodes */
+#define MAXI_CMD_READ          0x02
+#define MAXI_CMD_WRITE         0x03
+/* other values not used */
+
+/* MaxiLife NBA Hardware monitoring tokens */
+
+/* Alarm tokens (0x1xxx) */
+#define MAXI_TOK_ALARM(nr)    (0x1000 + (nr))
+#define MAXI_TOK_ALARM_EVENT   0x1000
+#define MAXI_TOK_ALARM_FAN     0x1001
+#define MAXI_TOK_ALARM_TEMP    0x1002
+#define MAXI_TOK_ALARM_VID     0x1003  /* voltages */
+#define MAXI_TOK_ALARM_AVID    0x1004  /* additional voltages */
+#define MAXI_TOK_ALARM_PWR     0x1101  /* power supply glitch */
+
+/* Fan status tokens (0x20xx) */
+#define MAXI_TOK_FAN(nr)      (0x2000 + (nr))
+#define MAXI_TOK_FAN_CPU       0x2000
+#define MAXI_TOK_FAN_PCI       0x2001
+#define MAXI_TOK_FAN_HDD       0x2002  /* hard disk bay fan */
+#define MAXI_TOK_FAN_SINK      0x2003  /* heatsink */
+
+/* Temperature status tokens (0x21xx) */
+#define MAXI_TOK_TEMP(nr)     (0x2100 + (nr))
+#define MAXI_TOK_TEMP_CPU1     0x2100
+#define MAXI_TOK_TEMP_CPU2     0x2101
+#define MAXI_TOK_TEMP_PCI      0x2102  /* PCI/ambient temp */
+#define MAXI_TOK_TEMP_HDD      0x2103  /* hard disk bay temp */
+#define MAXI_TOK_TEMP_MEM      0x2104  /* mother board temp */
+#define MAXI_TOK_TEMP_CPU      0x2105  /* CPU reference temp */
+
+/* Voltage status tokens (0x22xx) */
+#define MAXI_TOK_VID(nr)      (0x2200 + (nr))
+#define MAXI_TOK_VID_12        0x2200  /* +12 volt */
+#define MAXI_TOK_VID_CPU1      0x2201  /* cpu 1 voltage */
+#define MAXI_TOK_VID_CPU2      0x2202  /* cpu 2 voltage */
+#define MAXI_TOK_VID_L2        0x2203  /* level 2 cache voltage */
+#define MAXI_TOK_VID_M12       0x2204  /* -12 volt */
+
+/* Additive voltage status tokens (0x23xx) */
+#define MAXI_TOK_AVID(nr)     (0x2300 + (nr))
+#define MAXI_TOK_AVID_15       0x2300  /* 1.5 volt */
+#define MAXI_TOK_AVID_18       0x2301  /* 1.8 volt */
+#define MAXI_TOK_AVID_25       0x2302  /* 2.5 volt */
+#define MAXI_TOK_AVID_33       0x2303  /* 3.3 volt */
+#define MAXI_TOK_AVID_5        0x2304  /* 5 volt */
+#define MAXI_TOK_AVID_M5       0x2305  /* -5 volt */
+#define MAXI_TOK_AVID_BAT      0x2306  /* battery voltage */
+
+/* Threshold tokens (0x3xxx) */
+#define MAXI_TOK_MIN(token)    ((token) + 0x1000)
+#define MAXI_TOK_MAX(token)    ((token) + 0x1800)
+
+/* LCD Panel (0x4xxx) */
+#define MAXI_TOK_LCD(nr)      (0x4000 + (nr))
+#define MAXI_TOK_LCD_LINE1     0x4000
+#define MAXI_TOK_LCD_LINE2     0x4001
+#define MAXI_TOK_LCD_LINE3     0x4002
+#define MAXI_TOK_LCD_LINE4     0x4003
+
+                              /* 0xfe: fan off, 0xff: stopped (alarm) */
+                              /* or not available */
+#define FAN99_FROM_REG(val)    ((val)==0xfe ? 0 : (val)==0xff ? -1 : ((val)*39))
+
+                              /* when no CPU2 temp is 127 (0x7f) */
+#define TEMP99_FROM_REG(val)   ((val)==0x7f ? -1 : (val)==0xff ? -1 : (val))
+
+#define VID99_FROM_REG(nr,val) ((val)==0xff ? 0 : \
+                                (nr)==1 ? ((val) * 608) : \
+                                (nr)==2 ? ((val) * 160) : \
+                                (nr)==3 ? ((val) * 160) : \
+                                (nr)==4 ? (val) /* no formula spcified */ : \
+                                (nr)==5 ? ((val) * 823 - 149140) : 0)
+
+
+/* The following product codenames apply:
+     Cristal/Geronimo: HP KAYAK XU/XAs
+                       (Dual Pentium II Slot 1, Deschutes/Klamath)
+     Cognac: HP KAYAK XU (Dual Xeon [Slot 2] 400/450 Mhz)
+     Ashaki: HP KAYAK XA (Pentium II Slot 1, monoprocessor)
+     NBA:    New BIOS Architecture, Kayak XU800, XM600, ... */
+
+enum maxi_type { cristal, cognac, ashaki, nba };
+enum sensor_type { fan, temp, vid, pll, lcd, alarm };
+
+/* For each registered MaxiLife controller, we need to keep some data in
+   memory. That data is pointed to by maxi_list[NR]->data. The structure
+   itself is dynamically allocated, at the same time when a new MaxiLife
+   client is allocated. We assume MaxiLife will only be present on the
+   SMBus and not on the ISA bus. */
+struct maxi_data {
+       struct i2c_client client;
+       struct semaphore lock;
+       int sysctl_id;
+       enum maxi_type type;
+
+       struct semaphore update_lock;
+       char valid;             /* !=0 if following fields are valid */
+       unsigned long last_updated;     /* In jiffies */
+
+       u8 fan[4];              /* Register value */
+       u8 fan_min[4];          /* Register value */
+       u8 fan_speed[4];        /* Register value */
+       u8 fan_div[4];          /* Static value */
+       u8 temp[6];             /* Register value */
+       u8 temp_max[6];         /* Static value */
+       u8 temp_hyst[6];        /* Static value */
+       u8 pll;                 /* Register value */
+       u8 pll_min;             /* Register value */
+       u8 pll_max;             /* register value */
+       u8 vid[5];              /* Register value */
+       u8 vid_min[5];          /* Register value */
+       u8 vid_max[5];          /* Register value */
+       u8 lcd[4][17];          /* Four LCD lines */
+       u16 alarms;             /* Register encoding, combined */
+};
+
+
+static int maxi_attach_adapter(struct i2c_adapter *adapter);
+static int maxi_detect(struct i2c_adapter *adapter, int address,
+                      unsigned short flags, int kind);
+static int maxi_detach_client(struct i2c_client *client);
+
+static int maxi_read_value(struct i2c_client *client, u8 register);
+static int maxi_read_token(struct i2c_client *client, u16 token);
+#ifndef NOWRITE
+static int maxi_write_value(struct i2c_client *client, u8 register,
+                           u8 value);
+#endif
+static int maxi_write_token_loop(struct i2c_client *client, u16 token,
+                                u8 len, u8 * values);
+
+static void maxi_update_client(struct i2c_client *client);
+static void maxi99_update_client(struct i2c_client *client,
+                                enum sensor_type sensor, int which);
+static void maxi_init_client(struct i2c_client *client);
+
+static void maxi_fan(struct i2c_client *client, int operation,
+                    int ctl_name, int *nrels_mag, long *results);
+static void maxi99_fan(struct i2c_client *client, int operation,
+                      int ctl_name, int *nrels_mag, long *results);
+static void maxi_temp(struct i2c_client *client, int operation,
+                     int ctl_name, int *nrels_mag, long *results);
+static void maxi99_temp(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void maxi_pll(struct i2c_client *client, int operation,
+                    int ctl_name, int *nrels_mag, long *results);
+static void maxi_vid(struct i2c_client *client, int operation,
+                    int ctl_name, int *nrels_mag, long *results);
+static void maxi99_vid(struct i2c_client *client, int operation,
+                      int ctl_name, int *nrels_mag, long *results);
+static void maxi_lcd(struct i2c_client *client, int operation,
+                    int ctl_name, int *nrels_mag, long *results);
+static void maxi_alarms(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+
+/* The driver. I choose to use type i2c_driver, as at is identical to
+   the smbus_driver. */
+static struct i2c_driver maxi_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "HP MaxiLife driver",
+       .id             = I2C_DRIVERID_MAXILIFE,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = maxi_attach_adapter,
+       .detach_client  = maxi_detach_client,
+};
+
+static int maxi_id = 0;
+
+/* Default firmware version. Use module option "maxi_version"
+   to set desired version. Auto detect is not yet working */
+static int maxi_version = cristal;
+
+/* The /proc/sys entries */
+
+/* -- SENSORS SYSCTL START -- */
+#define MAXI_SYSCTL_FAN1   1101        /* Rotations/min */
+#define MAXI_SYSCTL_FAN2   1102        /* Rotations/min */
+#define MAXI_SYSCTL_FAN3   1103        /* Rotations/min */
+#define MAXI_SYSCTL_FAN4   1104        /* Rotations/min */
+#define MAXI_SYSCTL_TEMP1  1201        /* Degrees Celcius */
+#define MAXI_SYSCTL_TEMP2  1202        /* Degrees Celcius */
+#define MAXI_SYSCTL_TEMP3  1203        /* Degrees Celcius */
+#define MAXI_SYSCTL_TEMP4  1204        /* Degrees Celcius */
+#define MAXI_SYSCTL_TEMP5  1205        /* Degrees Celcius */
+#define MAXI_SYSCTL_TEMP6  1206        /* Degrees Celcius */
+#define MAXI_SYSCTL_PLL    1301        /* MHz */
+#define MAXI_SYSCTL_VID1   1401        /* Volts / 6.337, for nba just Volts */
+#define MAXI_SYSCTL_VID2   1402        /* Volts */
+#define MAXI_SYSCTL_VID3   1403        /* Volts */
+#define MAXI_SYSCTL_VID4   1404        /* Volts */
+#define MAXI_SYSCTL_VID5   1405        /* Volts */
+#define MAXI_SYSCTL_LCD1   1501        /* Line 1 of LCD */
+#define MAXI_SYSCTL_LCD2   1502        /* Line 2 of LCD */
+#define MAXI_SYSCTL_LCD3   1503        /* Line 3 of LCD */
+#define MAXI_SYSCTL_LCD4   1504        /* Line 4 of LCD */
+#define MAXI_SYSCTL_ALARMS 2001        /* Bitvector (see below) */
+
+#define MAXI_ALARM_VID4      0x0001
+#define MAXI_ALARM_TEMP2     0x0002
+#define MAXI_ALARM_VID1      0x0004
+#define MAXI_ALARM_VID2      0x0008
+#define MAXI_ALARM_VID3      0x0010
+#define MAXI_ALARM_PLL       0x0080
+#define MAXI_ALARM_TEMP4     0x0100
+#define MAXI_ALARM_TEMP5     0x0200
+#define MAXI_ALARM_FAN1      0x1000
+#define MAXI_ALARM_FAN2      0x2000
+#define MAXI_ALARM_FAN3      0x4000
+
+#define MAXI_ALARM_FAN       0x0100    /* To be used with  MaxiLife'99 */
+#define MAXI_ALARM_VID       0x0200    /* The MSB specifies which sensor */
+#define MAXI_ALARM_TEMP      0x0400    /* in the alarm group failed, i.e.: */
+#define MAXI_ALARM_VADD      0x0800    /* 0x0402 = TEMP2 failed = CPU2 temp */
+
+/* -- SENSORS SYSCTL END -- */
+
+/* These files are created for each detected MaxiLife processor.
+   This is just a template; though at first sight, you might think we
+   could use a statically allocated list, we need some way to get back
+   to the parent - which is done through one of the 'extra' fields 
+   which are initialized when a new copy is allocated. */
+static ctl_table maxi_dir_table_template[] = {
+       {MAXI_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &maxi_fan},
+       {MAXI_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &maxi_fan},
+       {MAXI_SYSCTL_FAN3, "fan3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &maxi_fan},
+       {MAXI_SYSCTL_FAN4, "fan4", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &maxi_fan},
+       {MAXI_SYSCTL_TEMP1, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &maxi_temp},
+       {MAXI_SYSCTL_TEMP2, "temp2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &maxi_temp},
+       {MAXI_SYSCTL_TEMP3, "temp3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &maxi_temp},
+       {MAXI_SYSCTL_TEMP4, "temp4", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &maxi_temp},
+       {MAXI_SYSCTL_TEMP5, "temp5", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &maxi_temp},
+       {MAXI_SYSCTL_TEMP6, "temp6", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &maxi_temp},
+       {MAXI_SYSCTL_PLL, "pll", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &maxi_pll},
+       {MAXI_SYSCTL_VID1, "vid1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &maxi_vid},
+       {MAXI_SYSCTL_VID2, "vid2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &maxi_vid},
+       {MAXI_SYSCTL_VID3, "vid3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &maxi_vid},
+       {MAXI_SYSCTL_VID4, "vid4", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &maxi_vid},
+       {MAXI_SYSCTL_VID5, "vid5", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &maxi_vid},
+       {MAXI_SYSCTL_LCD1, "lcd1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &maxi_lcd},
+       {MAXI_SYSCTL_LCD2, "lcd2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &maxi_lcd},
+       {MAXI_SYSCTL_LCD3, "lcd3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &maxi_lcd},
+       {MAXI_SYSCTL_LCD4, "lcd4", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &maxi_lcd},
+       {MAXI_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &maxi_alarms},
+       {0}
+};
+
+/* This function is called when:
+    - maxi_driver is inserted (when this module is loaded), for each
+      available adapter
+    - when a new adapter is inserted (and maxi_driver is still present) */
+static int maxi_attach_adapter(struct i2c_adapter *adapter)
+{
+       return i2c_detect(adapter, &addr_data, maxi_detect);
+}
+
+/* This function is called by i2c_detect */
+int maxi_detect(struct i2c_adapter *adapter, int address,
+               unsigned short flags, int kind)
+{
+       struct i2c_client *new_client;
+       struct maxi_data *data;
+       enum maxi_type type = 0;
+       int i, j, err = 0;
+       const char *type_name = NULL, *client_name = NULL;
+
+       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
+               goto ERROR0;
+
+       /* OK. For now, we presume we have a valid client. We now create the
+          client structure, even though we cannot fill it completely yet.
+          But it allows us to access maxi_{read,write}_value. */
+       if (!(data = kmalloc(sizeof(struct maxi_data), GFP_KERNEL))) {
+               err = -ENOMEM;
+               goto ERROR0;
+       }
+
+       /* Fill the new client structure with data */
+       new_client = &data->client;
+       new_client->addr = address;
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &maxi_driver;
+       new_client->flags = 0;
+
+       /* Now we do the remaining detection. */
+       if (kind < 0) {
+               if (i2c_smbus_read_byte_data
+                   (new_client, MAXI_REG_MBX_STATUS) < 0)
+                       goto ERROR2;
+       }
+
+       /* Determine the chip type - only one kind supported */
+       if (kind <= 0)
+               kind = maxilife;
+
+       if (kind == maxilife) {
+               /* Detect if the machine has a MaxiLife NBA controller.
+                  The right way to perform this check is to do a read/modify/write
+                  on register MbxStatus (5A):
+                  - Read 5A (value 0 for non-NBA firmware, FF (MbxIdle on NBA-firmware)
+                  - Write 55 on 5A, then read back 5A
+                  Non-NBA firmware: value is 55 (reg 5A is a standard writable reg)
+                  NBA firmaware: value is FF (write-protect on MbxStatus active) */
+               int stat;
+               i2c_smbus_write_byte_data(new_client, MAXI_REG_MBX_STATUS,
+                                         0x55);
+               stat =
+                   i2c_smbus_read_byte_data(new_client,
+                                            MAXI_REG_MBX_STATUS);
+
+               /*if (stat == MAXI_STAT_IDLE || stat == MAXI_STAT_OK) */
+               if (stat != 0x55)
+                       maxi_version = nba;
+#ifdef AUTODETECT
+               else {
+                       /* The right way to get the platform info is to read the firmware
+                          revision from serial EEPROM (addr=0x54), at offset 0x0045.
+                          This is a string as:
+                          "CG 00.04" -> Cristal [XU] / Geronimo [XAs]
+                          "CO 00.03" -> Cognac [XU]
+                          "AS 00.01" -> Ashaki [XA] */
+#if 0
+                       int biosctl;
+                       biosctl =
+                           i2c_smbus_read_byte_data(new_client,
+                                                    MAXI_REG_BIOS_CTRL);
+                       i2c_smbus_write_byte_data(new_client,
+                                                 MAXI_REG_BIOS_CTRL,
+                                                 biosctl | 4);
+                       err = eeprom_read_byte_data(adapter, 0x54, 0x45);
+                       i2c_smbus_write_byte_data(new_client,
+                                                 MAXI_REG_BIOS_CTRL,
+                                                 biosctl);
+#endif
+                       int i;
+                       char *biosmem, *bm;
+                       bm = biosmem = ioremap(0xe0000, 0x20000);
+                       if (biosmem) {
+                               printk("begin of bios search\n");
+                               for (i = 0; i < 0x20000; i++) {
+                                       if (*bm == 'C') {
+                                               char *s = bm;
+                                               while (s && isprint(*s)) {
+                                                       printk("%c", *s);
+                                                       s++;
+                                               }
+                                               printk("\n");
+                                               if (!strncmp
+                                                   (bm, "CG 00.04", 8)) {
+                                                       maxi_version =
+                                                           cristal;
+                                                       printk
+                                                           ("maxilife: found MaxiLife Rev CG 00.04\n");
+                                                       break;
+                                               }
+                                               if (!strncmp
+                                                   (bm, "CO 00.03", 8)) {
+                                                       maxi_version =
+                                                           cognac;
+                                                       printk
+                                                           ("maxilife: found MaxiLife Rev CO 00.03\n");
+                                                       break;
+                                               }
+                                       }
+                                       if (*bm == 'A' && *(bm + 1) == 'S') {
+                                               char *s = bm;
+                                               while (s && isprint(*s)) {
+                                                       printk("%c", *s);
+                                                       s++;
+                                               }
+                                               printk("\n");
+                                               if (!strncmp
+                                                   (bm, "AS 00.01", 8)) {
+                                                       maxi_version =
+                                                           ashaki;
+                                                       printk
+                                                           ("maxilife: found MaxiLife Rev AS 00.01\n");
+                                                       break;
+                                               }
+                                       }
+                                       bm++;
+                               }
+                               printk("end of bios search\n");
+                       } else
+                               printk("could not map bios memory\n");
+               }
+#endif
+
+               if (maxi_version == cristal) {
+                       type = cristal;
+                       type_name = "maxilife-cg";
+                       client_name = "HP MaxiLife Rev CG 00.04";
+                       printk
+                           ("maxilife: HP KAYAK XU/XAs (Dual Pentium II Slot 1)\n");
+               } else if (maxi_version == cognac) {
+                       type = cognac;
+                       type_name = "maxilife-co";
+                       client_name = "HP MaxiLife Rev CO 00.03";
+                       printk
+                           ("maxilife: HP KAYAK XU (Dual Xeon Slot 2 400/450 Mhz)\n");
+               } else if (maxi_version == ashaki) {
+                       type = ashaki;
+                       type_name = "maxilife-as";
+                       client_name = "HP MaxiLife Rev AS 00.01";
+                       printk
+                           ("maxilife: HP KAYAK XA (Pentium II Slot 1, monoprocessor)\n");
+               } else if (maxi_version == nba) {
+                       type = nba;
+                       type_name = "maxilife-nba";
+                       client_name = "HP MaxiLife NBA";
+                       printk("maxilife: HP KAYAK XU800/XM600\n");
+               } else {
+#ifdef AUTODETECT
+                       printk
+                           ("maxilife: Warning: probed non-maxilife chip?!? (%x)\n",
+                            err);
+#else
+                       printk
+                           ("maxilife: Error: specified wrong maxi_version (%d)\n",
+                            maxi_version);
+#endif
+                       goto ERROR2;
+               }
+       }
+
+       /* Fill in the remaining client fields and put it into the global list */
+       strcpy(new_client->name, client_name);
+       ((struct maxi_data *) (new_client->data))->type = type;
+
+       for (i = 0; i < 4; i++)
+               for (j = 0; j < 17; j++)
+                           ((struct maxi_data *) (new_client->data))->
+                           lcd[i][j] = (u8) 0;
+
+       new_client->id = maxi_id++;
+
+       data->valid = 0;
+       init_MUTEX(&data->lock);
+       init_MUTEX(&data->update_lock);
+
+       /* Tell i2c-core that a new client has arrived */
+       if ((err = i2c_attach_client(new_client)))
+               goto ERROR2;
+
+       /* Register a new directory entry with module sensors */
+       if ((err = i2c_register_entry(new_client, type_name,
+                                         maxi_dir_table_template)) < 0)
+               goto ERROR4;
+       data->sysctl_id = err;
+
+       /* Initialize the MaxiLife chip */
+       maxi_init_client(new_client);
+       return 0;
+
+       /* OK, this is not exactly good programming practice, usually.
+          But it is very code-efficient in this case. */
+      ERROR4:
+       i2c_detach_client(new_client);
+      ERROR2:
+       kfree(data);
+      ERROR0:
+       return err;
+}
+
+/* This function is called whenever a client should be removed:
+    - maxi_driver is removed (when this module is unloaded)
+    - when an adapter is removed which has a maxi client (and maxi_driver
+      is still present). */
+static int maxi_detach_client(struct i2c_client *client)
+{
+       int err;
+
+       i2c_deregister_entry(((struct maxi_data *) (client->data))->
+                                sysctl_id);
+
+       if ((err = i2c_detach_client(client))) {
+               printk
+                   ("maxilife: Client deregistration failed, client not detached.\n");
+               return err;
+       }
+       kfree(client->data);
+       return 0;
+}
+
+/* Read byte from specified register (-1 in case of error, value otherwise). */
+static int maxi_read_value(struct i2c_client *client, u8 reg)
+{
+       return i2c_smbus_read_byte_data(client, reg);
+}
+
+/* Read the byte value for a MaxiLife token (-1 in case of error, value otherwise */
+static int maxi_read_token(struct i2c_client *client, u16 token)
+{
+       u8 lowToken, highToken;
+       int error, value;
+
+       lowToken = LOW(token);
+       highToken = HIGH(token);
+
+       /* Set mailbox status register to idle state. */
+       error =
+           i2c_smbus_write_byte_data(client, MAXI_REG_MBX_STATUS,
+                                     MAXI_STAT_IDLE);
+       if (error < 0)
+               return error;
+
+       /* Check for mailbox idle state. */
+       error = i2c_smbus_read_byte_data(client, MAXI_REG_MBX_STATUS);
+       if (error != MAXI_STAT_IDLE)
+               return -1;
+
+       /* Write the most significant byte of the token we want to read. */
+       error =
+           i2c_smbus_write_byte_data(client, MAXI_REG_MBX_TOKEN_H,
+                                     highToken);
+       if (error < 0)
+               return error;
+
+       /* Write the least significant byte of the token we want to read. */
+       error =
+           i2c_smbus_write_byte_data(client, MAXI_REG_MBX_TOKEN_L,
+                                     lowToken);
+       if (error < 0)
+               return error;
+
+       /* Write the read token opcode to the mailbox. */
+       error =
+           i2c_smbus_write_byte_data(client, MAXI_REG_MBX_CMD,
+                                     MAXI_CMD_READ);
+       if (error < 0)
+               return error;
+
+       /* Check for transaction completion */
+       do {
+               error =
+                   i2c_smbus_read_byte_data(client, MAXI_REG_MBX_STATUS);
+       } while (error == MAXI_STAT_BUSY);
+       if (error != MAXI_STAT_OK)
+               return -1;
+
+       /* Read the value of the token. */
+       value = i2c_smbus_read_byte_data(client, MAXI_REG_MBX_DATA);
+       if (value == -1)
+               return -1;
+
+       /* set mailbox status to idle to complete transaction. */
+       error =
+           i2c_smbus_write_byte_data(client, MAXI_REG_MBX_STATUS,
+                                     MAXI_STAT_IDLE);
+       if (error < 0)
+               return error;
+
+       return value;
+}
+
+#ifndef NOWRITE
+/* Write byte to specified register (-1 in case of error, 0 otherwise). */
+static int maxi_write_value(struct i2c_client *client, u8 reg, u8 value)
+{
+       return i2c_smbus_write_byte_data(client, reg, value);
+}
+#endif
+
+/* Write a set of len byte values to MaxiLife token (-1 in case of error, 0 otherwise). */
+int maxi_write_token_loop(struct i2c_client *client, u16 token, u8 len,
+                         u8 * values)
+{
+       u8 lowToken, highToken, bCounter;
+       int error;
+
+       lowToken = LOW(token);
+       highToken = HIGH(token);
+
+       /* Set mailbox status register to idle state. */
+       error =
+           i2c_smbus_write_byte_data(client, MAXI_REG_MBX_STATUS,
+                                     MAXI_STAT_IDLE);
+       if (error < 0)
+               return error;
+
+       /* Check for mailbox idle state. */
+       error = i2c_smbus_read_byte_data(client, MAXI_REG_MBX_STATUS);
+       if (error != MAXI_STAT_IDLE)
+               return -1;
+
+       for (bCounter = 0; (bCounter < len && bCounter < 32); bCounter++) {
+               error =
+                   i2c_smbus_write_byte_data(client,
+                                             (u8) (MAXI_REG_MBX_DATA +
+                                                   bCounter),
+                                             values[bCounter]);
+               if (error < 0)
+                       return error;
+       }
+
+       /* Write the most significant byte of the token we want to read. */
+       error =
+           i2c_smbus_write_byte_data(client, MAXI_REG_MBX_TOKEN_H,
+                                     highToken);
+       if (error < 0)
+               return error;
+
+       /* Write the least significant byte of the token we want to read. */
+       error =
+           i2c_smbus_write_byte_data(client, MAXI_REG_MBX_TOKEN_L,
+                                     lowToken);
+       if (error < 0)
+               return error;
+
+       /* Write the write token opcode to the mailbox. */
+       error =
+           i2c_smbus_write_byte_data(client, MAXI_REG_MBX_CMD,
+                                     MAXI_CMD_WRITE);
+       if (error < 0)
+               return error;
+
+       /* Check for transaction completion */
+       do {
+               error =
+                   i2c_smbus_read_byte_data(client, MAXI_REG_MBX_STATUS);
+       } while (error == MAXI_STAT_BUSY);
+       if (error != MAXI_STAT_OK)
+               return -1;
+
+       /* set mailbox status to idle to complete transaction. */
+       return i2c_smbus_write_byte_data(client, MAXI_REG_MBX_STATUS,
+                                        MAXI_STAT_IDLE);
+}
+
+/* Called when we have found a new MaxiLife. It should set limits, etc. */
+static void maxi_init_client(struct i2c_client *client)
+{
+       struct maxi_data *data = client->data;
+
+       if (data->type == nba) {
+               strcpy(data->lcd[2], " Linux MaxiLife");
+               maxi_write_token_loop(client, MAXI_TOK_LCD(2),
+                                     strlen(data->lcd[2]) + 1,
+                                     data->lcd[2]);
+       }
+}
+
+static void maxi_update_client(struct i2c_client *client)
+{
+       struct maxi_data *data = client->data;
+       int i;
+
+       if (data->type == nba) {
+               printk
+                   ("maxi_update_client should never be called by nba\n");
+               return;
+       }
+
+       down(&data->update_lock);
+
+       if ((jiffies - data->last_updated > HZ + HZ / 2) ||
+           (jiffies < data->last_updated) || !data->valid) {
+
+#ifdef DEBUG
+               printk("maxilife: Starting MaxiLife update\n");
+#endif
+               for (i = 0; i < 5; i++)
+                       data->temp[i] =
+                           maxi_read_value(client, MAXI_REG_TEMP(i));
+               switch (data->type) {
+               case cristal:
+                       data->temp[0] = 0;      /* not valid */
+                       data->temp_max[0] = 0;
+                       data->temp_hyst[0] = 0;
+                       data->temp_max[1] = 110;        /* max PCI slot temp */
+                       data->temp_hyst[1] = 100;
+                       data->temp_max[2] = 120;        /* max BX chipset temp */
+                       data->temp_hyst[2] = 110;
+                       data->temp_max[3] = 100;        /* max HDD temp */
+                       data->temp_hyst[3] = 90;
+                       data->temp_max[4] = 120;        /* max CPU temp */
+                       data->temp_hyst[4] = 110;
+                       break;
+
+               case cognac:
+                       data->temp_max[0] = 120;        /* max CPU1 temp */
+                       data->temp_hyst[0] = 110;
+                       data->temp_max[1] = 110;        /* max PCI slot temp */
+                       data->temp_hyst[1] = 100;
+                       data->temp_max[2] = 120;        /* max CPU2 temp */
+                       data->temp_hyst[2] = 110;
+                       data->temp_max[3] = 100;        /* max HDD temp */
+                       data->temp_hyst[3] = 90;
+                       data->temp_max[4] = 120;        /* max reference CPU temp */
+                       data->temp_hyst[4] = 110;
+                       break;
+
+               case ashaki:
+                       data->temp[0] = 0;      /* not valid */
+                       data->temp_max[0] = 0;
+                       data->temp_hyst[0] = 0;
+                       data->temp_max[1] = 110;        /* max PCI slot temp */
+                       data->temp_hyst[1] = 100;
+                       data->temp[2] = 0;      /* not valid */
+                       data->temp_max[2] = 0;
+                       data->temp_hyst[2] = 0;
+                       data->temp_max[3] = 100;        /* max HDD temp */
+                       data->temp_hyst[3] = 90;
+                       data->temp_max[4] = 120;        /* max CPU temp */
+                       data->temp_hyst[4] = 110;
+                       break;
+
+               default:
+                       printk("maxilife: Unknown MaxiLife chip\n");
+               }
+               data->temp[5] = 0;      /* only used by MaxiLife'99 */
+               data->temp_max[5] = 0;
+               data->temp_hyst[5] = 0;
+
+               for (i = 0; i < 3; i++) {
+                       data->fan[i] =
+                           maxi_read_value(client, MAXI_REG_FAN(i));
+                       data->fan_speed[i] =
+                           maxi_read_value(client, MAXI_REG_FAN_SPEED(i));
+                       data->fan_div[i] = 4;
+                       if (data->type == ashaki)
+                               data->fan_min[i] =
+                                   maxi_read_value(client,
+                                                   MAXI_REG_FAN_MINAS(i));
+                       else
+                               data->fan_min[i] =
+                                   maxi_read_value(client,
+                                                   MAXI_REG_FAN_MIN(i));
+               }
+               data->fan[3] = 0xff;    /* only used by MaxiLife'99 */
+               data->fan_speed[3] = 0;
+               data->fan_div[3] = 4;   /* avoid possible /0 */
+               data->fan_min[3] = 0;
+
+               data->pll = maxi_read_value(client, MAXI_REG_PLL);
+               data->pll_min = maxi_read_value(client, MAXI_REG_PLL_MIN);
+               data->pll_max = maxi_read_value(client, MAXI_REG_PLL_MAX);
+
+               for (i = 0; i < 4; i++) {
+                       data->vid[i] =
+                           maxi_read_value(client, MAXI_REG_VID(i));
+                       data->vid_min[i] =
+                           maxi_read_value(client, MAXI_REG_VID_MIN(i));
+                       data->vid_max[i] =
+                           maxi_read_value(client, MAXI_REG_VID_MAX(i));
+               }
+               switch (data->type) {
+               case cristal:
+                       data->vid[3] = 0;       /* no voltage cache L2 */
+                       data->vid_min[3] = 0;
+                       data->vid_max[3] = 0;
+                       break;
+
+               case cognac:
+                       break;
+
+               case ashaki:
+                       data->vid[1] = 0;       /* no voltage CPU 2 */
+                       data->vid_min[1] = 0;
+                       data->vid_max[1] = 0;
+                       data->vid[3] = 0;       /* no voltage cache L2 */
+                       data->vid_min[3] = 0;
+                       data->vid_max[3] = 0;
+                       break;
+
+               default:
+                       printk("maxilife: Unknown MaxiLife chip\n");
+               }
+               data->vid[4] = 0;       /* only used by MaxliLife'99 */
+               data->vid_min[4] = 0;
+               data->vid_max[4] = 0;
+
+               data->alarms = maxi_read_value(client, MAXI_REG_DIAG_RT1) +
+                   (maxi_read_value(client, MAXI_REG_DIAG_RT2) << 8);
+
+               data->last_updated = jiffies;
+               data->valid = 1;
+       }
+
+       up(&data->update_lock);
+}
+
+void maxi99_update_client(struct i2c_client *client,
+                         enum sensor_type sensor, int which)
+{
+       static unsigned long last_updated[6][6];        /* sensor, which */
+       struct maxi_data *data = client->data;
+
+       down(&data->update_lock);
+
+       /*maxi_write_token_loop(client, MAXI_TOK_LCD_LINE3, 13, "Linux 2.2.13"); */
+
+       if ((jiffies - last_updated[sensor][which] > 2 * HZ) ||
+           (jiffies < last_updated[sensor][which]
+            || !last_updated[sensor][which])) {
+
+               int tmp, i;
+
+               switch (sensor) {
+               case fan:
+                       for (i = 0; i < 4; i++) {
+                               if (i == which) {
+                                       tmp =
+                                           maxi_read_token(client,
+                                                           MAXI_TOK_FAN
+                                                           (i));
+                                       data->fan[i] =
+                                           maxi_read_token(client,
+                                                           MAXI_TOK_FAN
+                                                           (i));
+                                       data->fan_speed[i] =
+                                           maxi_read_token(client,
+                                                           MAXI_TOK_MAX
+                                                           (MAXI_TOK_FAN
+                                                            (i)));
+                                       data->fan_div[i] = 1;
+                                       data->fan_min[i] = 0;
+                               }
+                       }
+                       break;
+
+               case temp:
+                       for (i = 0; i < 6; i++) {
+                               if (i == which) {
+                                       data->temp[i] =
+                                           maxi_read_token(client,
+                                                           MAXI_TOK_TEMP
+                                                           (i));
+                                       data->temp_max[i] =
+                                           maxi_read_token(client,
+                                                           MAXI_TOK_MAX
+                                                           (MAXI_TOK_TEMP
+                                                            (i)));
+                                       data->temp_hyst[i] =
+                                           data->temp_max[i] - 5;
+                               }
+                       }
+                       break;
+
+               case vid:
+                       for (i = 0; i < 5; i++) {
+                               if (i == which) {
+                                       data->vid[i] =
+                                           maxi_read_token(client,
+                                                           MAXI_TOK_VID
+                                                           (i));
+                                       data->vid_min[i] =
+                                           maxi_read_token(client,
+                                                           MAXI_TOK_MIN
+                                                           (MAXI_TOK_VID
+                                                            (i)));
+                                       data->vid_max[i] =
+                                           maxi_read_token(client,
+                                                           MAXI_TOK_MAX
+                                                           (MAXI_TOK_VID
+                                                            (i)));
+                               }
+                       }
+                       break;
+
+               case pll:
+                       data->pll = 0;
+                       data->pll_min = 0;
+                       data->pll_max = 0;
+                       break;
+
+               case alarm:
+                       data->alarms =
+                           (maxi_read_token(client, MAXI_TOK_ALARM_EVENT)
+                            << 8);
+                       if (data->alarms)
+                               data->alarms +=
+                                   data->alarms ==
+                                   (1 << 8) ? maxi_read_token(client,
+                                                              MAXI_TOK_ALARM_FAN)
+                                   : data->alarms ==
+                                   (2 << 8) ? maxi_read_token(client,
+                                                              MAXI_TOK_ALARM_VID)
+                                   : data->alarms ==
+                                   (4 << 8) ? maxi_read_token(client,
+                                                              MAXI_TOK_ALARM_TEMP)
+                                   : data->alarms ==
+                                   (8 << 8) ? maxi_read_token(client,
+                                                              MAXI_TOK_ALARM_FAN)
+                                   : 0;
+                       break;
+
+               default:
+                       printk("maxilife: Unknown sensor type\n");
+               }
+
+               last_updated[sensor][which] = jiffies;
+               data->valid = 1;
+       }
+
+       up(&data->update_lock);
+}
+
+/* The next few functions are the call-back functions of the /proc/sys and
+   sysctl files. Which function is used is defined in the ctl_table in
+   the extra1 field.
+   Each function must return the magnitude (power of 10 to divide the data
+   with) if it is called with operation==SENSORS_PROC_REAL_INFO. It must
+   put a maximum of *nrels elements in results reflecting the data of this
+   file, and set *nrels to the number it actually put in it, if operation==
+   SENSORS_PROC_REAL_READ. Finally, it must get upto *nrels elements from
+   results and write them to the chip, if operations==SENSORS_PROC_REAL_WRITE.
+   Note that on SENSORS_PROC_REAL_READ, I do not check whether results is
+   large enough (by checking the incoming value of *nrels). This is not very
+   good practice, but as long as you put less than about 5 values in results,
+   you can assume it is large enough. */
+void maxi_fan(struct i2c_client *client, int operation, int ctl_name,
+             int *nrels_mag, long *results)
+{
+       struct maxi_data *data = client->data;
+       int nr;
+
+       if (data->type == nba) {
+               maxi99_fan(client, operation, ctl_name, nrels_mag,
+                          results);
+               return;
+       }
+
+       nr = ctl_name - MAXI_SYSCTL_FAN1 + 1;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               maxi_update_client(client);
+               results[0] = FAN_FROM_REG(data->fan_min[nr - 1]);
+               results[1] = data->fan_div[nr - 1];
+               results[2] = FAN_FROM_REG(data->fan[nr - 1]);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+#ifndef NOWRITE
+               if (*nrels_mag >= 1) {
+                       data->fan_min[nr - 1] = FAN_TO_REG(results[0]);
+                       maxi_write_value(client, MAXI_REG_FAN_MIN(nr),
+                                        data->fan_min[nr - 1]);
+               }
+#endif
+       }
+}
+
+void maxi99_fan(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       struct maxi_data *data = client->data;
+       int nr;
+
+       nr = ctl_name - MAXI_SYSCTL_FAN1 + 1;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               maxi99_update_client(client, fan, nr - 1);
+               results[0] = FAN99_FROM_REG(data->fan_min[nr - 1]);     /* min rpm */
+               results[1] = data->fan_div[nr - 1];     /* divisor */
+               results[2] = FAN99_FROM_REG(data->fan[nr - 1]); /* rpm */
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+#ifndef NOWRITE
+               /* still to do */
+               if (*nrels_mag >= 1) {
+                       data->fan_min[nr - 1] = FAN_TO_REG(results[0]);
+                       maxi_write_value(client, MAXI_REG_FAN_MIN(nr),
+                                        data->fan_min[nr - 1]);
+               }
+#endif
+       }
+}
+
+void maxi_temp(struct i2c_client *client, int operation, int ctl_name,
+              int *nrels_mag, long *results)
+{
+       struct maxi_data *data = client->data;
+       int nr;
+
+       if (data->type == nba) {
+               maxi99_temp(client, operation, ctl_name, nrels_mag,
+                           results);
+               return;
+       }
+
+       nr = ctl_name - MAXI_SYSCTL_TEMP1 + 1;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               maxi_update_client(client);
+               results[0] = TEMP_FROM_REG(data->temp_max[nr - 1]);
+               results[1] = TEMP_FROM_REG(data->temp_hyst[nr - 1]);
+               results[2] = TEMP_FROM_REG(data->temp[nr - 1]);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               /* temperature range can not be changed */
+       }
+}
+
+void maxi99_temp(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct maxi_data *data = client->data;
+       int nr;
+
+       nr = ctl_name - MAXI_SYSCTL_TEMP1 + 1;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               maxi99_update_client(client, temp, nr - 1);
+               results[0] = TEMP99_FROM_REG(data->temp_max[nr - 1]);
+               results[1] = TEMP99_FROM_REG(data->temp_hyst[nr - 1]);
+               results[2] = TEMP99_FROM_REG(data->temp[nr - 1]);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               /* temperature range can not be changed */
+       }
+}
+
+void maxi_pll(struct i2c_client *client, int operation, int ctl_name,
+             int *nrels_mag, long *results)
+{
+       struct maxi_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 2;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               if (data->type == nba)
+                       maxi99_update_client(client, pll, 0);
+               else
+                       maxi_update_client(client);
+               results[0] = PLL_FROM_REG(data->pll_min);
+               results[1] = PLL_FROM_REG(data->pll_max);
+               results[2] = PLL_FROM_REG(data->pll);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+#ifndef NOWRITE
+               if (*nrels_mag >= 1) {
+                       data->pll_min = PLL_TO_REG(results[0]);
+                       maxi_write_value(client, MAXI_REG_PLL_MIN,
+                                        data->pll_min);
+               }
+               if (*nrels_mag >= 2) {
+                       data->pll_max = PLL_TO_REG(results[1]);
+                       maxi_write_value(client, MAXI_REG_PLL_MAX,
+                                        data->pll_max);
+               }
+#endif
+       }
+}
+
+void maxi_vid(struct i2c_client *client, int operation, int ctl_name,
+             int *nrels_mag, long *results)
+{
+       struct maxi_data *data = client->data;
+       int nr;
+
+       if (data->type == nba) {
+               maxi99_vid(client, operation, ctl_name, nrels_mag,
+                          results);
+               return;
+       }
+
+       nr = ctl_name - MAXI_SYSCTL_VID1 + 1;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 4;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               maxi_update_client(client);
+               results[0] = VID_FROM_REG(data->vid_min[nr - 1]);
+               results[1] = VID_FROM_REG(data->vid_max[nr - 1]);
+               results[2] = VID_FROM_REG(data->vid[nr - 1]);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+#ifndef NOWRITE
+               if (*nrels_mag >= 1) {
+                       data->vid_min[nr - 1] = VID_TO_REG(results[0]);
+                       maxi_write_value(client, MAXI_REG_VID_MIN(nr),
+                                        data->vid_min[nr - 1]);
+               }
+               if (*nrels_mag >= 2) {
+                       data->vid_max[nr - 1] = VID_TO_REG(results[1]);
+                       maxi_write_value(client, MAXI_REG_VID_MAX(nr),
+                                        data->vid_max[nr - 1]);
+               }
+#endif
+       }
+}
+
+void maxi99_vid(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       struct maxi_data *data = client->data;
+       int nr = ctl_name - MAXI_SYSCTL_VID1 + 1;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 4;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               maxi99_update_client(client, vid, nr - 1);
+               results[0] = VID99_FROM_REG(nr, data->vid_min[nr - 1]);
+               results[1] = VID99_FROM_REG(nr, data->vid_max[nr - 1]);
+               results[2] = VID99_FROM_REG(nr, data->vid[nr - 1]);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+#ifndef NOWRITE
+               /* still to do */
+               if (*nrels_mag >= 1) {
+                       data->vid_min[nr - 1] = VID_TO_REG(results[0]);
+                       maxi_write_value(client, MAXI_REG_VID_MIN(nr),
+                                        data->vid_min[nr - 1]);
+               }
+               if (*nrels_mag >= 2) {
+                       data->vid_max[nr - 1] = VID_TO_REG(results[1]);
+                       maxi_write_value(client, MAXI_REG_VID_MAX(nr),
+                                        data->vid_max[nr - 1]);
+               }
+#endif
+       }
+}
+
+void maxi_lcd(struct i2c_client *client, int operation, int ctl_name,
+             int *nrels_mag, long *results)
+{
+       /* Allows writing and reading from LCD display */
+
+       struct maxi_data *data = client->data;
+       int nr;
+
+       if (data->type != nba)
+               return;
+
+       nr = ctl_name - MAXI_SYSCTL_LCD1 + 1;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               results[0] = *((long *) &data->lcd[nr - 1][0]);
+               results[1] = *((long *) &data->lcd[nr - 1][4]);
+               results[2] = *((long *) &data->lcd[nr - 1][8]);
+               results[3] = *((long *) &data->lcd[nr - 1][12]);
+               *nrels_mag = 4;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               /* 
+                  Writing a string to line 3 of the LCD can be done like:
+                  echo -n "Linux MaxiLife" | od -A n -l > \
+                  /proc/sys/dev/sensors/maxilife-nba-i2c-0-14/lcd3
+                */
+               if (*nrels_mag >= 1)
+                       *((long *) &data->lcd[nr - 1][0]) = results[0];
+               if (*nrels_mag >= 2)
+                       *((long *) &data->lcd[nr - 1][4]) = results[1];
+               if (*nrels_mag >= 3)
+                       *((long *) &data->lcd[nr - 1][8]) = results[2];
+               if (*nrels_mag >= 4)
+                       *((long *) &data->lcd[nr - 1][12]) = results[3];
+               maxi_write_token_loop(client, MAXI_TOK_LCD(nr - 1),
+                                     strlen(data->lcd[nr - 1]) + 1,
+                                     data->lcd[nr - 1]);
+#if 0
+               if (*nrels_mag >= 1)
+                       printk("nr=%d, result[0] = %.4s\n", nr,
+                              (char *) &results[0]);
+               if (*nrels_mag >= 2)
+                       printk("nr=%d, result[1] = %.4s\n", nr,
+                              (char *) &results[1]);
+               if (*nrels_mag >= 3)
+                       printk("nr=%d, result[2] = %.4s\n", nr,
+                              (char *) &results[2]);
+               if (*nrels_mag >= 4)
+                       printk("nr=%d, result[3] = %.4s\n", nr,
+                              (char *) &results[3]);
+#endif
+       }
+
+}
+
+void maxi_alarms(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct maxi_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               if (data->type == nba)
+                       maxi99_update_client(client, alarm, 0);
+               else
+                       maxi_update_client(client);
+               results[0] = ALARMS_FROM_REG(data->alarms);
+               *nrels_mag = 1;
+       }
+}
+
+static int __init sm_maxilife_init(void)
+{
+       printk("maxilife: Version %s (lm_sensors %s (%s))\n", version_str,
+              LM_VERSION, LM_DATE);
+       return i2c_add_driver(&maxi_driver);
+}
+
+static void __exit sm_maxilife_exit(void)
+{
+       i2c_del_driver(&maxi_driver);
+}
+
+
+
+MODULE_AUTHOR("Fons Rademakers <Fons.Rademakers@cern.ch>");
+MODULE_DESCRIPTION("HP MaxiLife driver");
+MODULE_PARM(maxi_version, "i");
+MODULE_PARM_DESC(maxi_version, "MaxiLife firmware version");
+
+module_init(sm_maxilife_init);
+module_exit(sm_maxilife_exit);
--- linux-old/drivers/sensors/mtp008.c  Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/mtp008.c      Mon Dec 13 20:18:51 2004
@@ -0,0 +1,1103 @@
+/*
+   mtp008.c - Part of lm_sensors, Linux kernel modules for hardware
+   monitoring
+   Copyright (C) 2001, 2004  Kris Van Hees <aedil@alchar.org>
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+MODULE_LICENSE("GPL");
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = {SENSORS_I2C_END};
+static unsigned short normal_i2c_range[] = {0x2c, 0x2e, SENSORS_I2C_END};
+static unsigned int normal_isa[] = {SENSORS_ISA_END};
+static unsigned int normal_isa_range[] = {SENSORS_ISA_END};
+
+/* Insmod parameters */
+SENSORS_INSMOD_1(mtp008);
+
+/* The MTP008 registers */
+/*      in0 .. in6 */
+#define MTP008_REG_IN(nr)              (0x20 + (nr))
+#define MTP008_REG_IN_MAX(nr)          (0x2b + (nr) * 2)
+#define MTP008_REG_IN_MIN(nr)          (0x2c + (nr) * 2)
+
+/*      temp1 */
+#define MTP008_REG_TEMP                        0x27
+#define MTP008_REG_TEMP_MAX            0x39
+#define MTP008_REG_TEMP_MIN            0x3a
+
+/*      fan1 .. fan3 */
+#define MTP008_REG_FAN(nr)             (0x27 + (nr))
+#define MTP008_REG_FAN_MIN(nr)         (0x3a + (nr))
+
+#define MTP008_REG_CONFIG              0x40
+#define MTP008_REG_INT_STAT1           0x41
+#define MTP008_REG_INT_STAT2           0x42
+
+#define MTP008_REG_SMI_MASK1           0x43
+#define MTP008_REG_SMI_MASK2           0x44
+
+#define MTP008_REG_NMI_MASK1           0x45
+#define MTP008_REG_NMI_MASK2           0x46
+
+#define MTP008_REG_VID_FANDIV          0x47
+
+#define MTP008_REG_I2C_ADDR            0x48
+
+#define MTP008_REG_RESET_VID4          0x49
+
+#define MTP008_REG_OVT_PROP            0x50
+
+#define MTP008_REG_BEEP_CTRL1          0x51
+#define MTP008_REG_BEEP_CTRL2          0x52
+
+/*      pwm1 .. pwm3  nr range 1-3 */
+#define MTP008_REG_PWM_CTRL(nr)                (0x52 + (nr))
+
+#define MTP008_REG_PIN_CTRL1           0x56
+#define MTP008_REG_PIN_CTRL2           0x57
+
+#define MTP008_REG_CHIPID              0x58
+
+/*
+ * Pin control register configuration constants.
+ */
+#define MTP008_CFG_VT1_PII             0x08
+#define MTP008_CFG_VT2_AIN             0x00
+#define MTP008_CFG_VT2_VT              0x03
+#define MTP008_CFG_VT2_PII             0x04
+#define MTP008_CFG_VT2_MASK            0x06
+#define MTP008_CFG_VT3_VT              0x01
+
+/* sensor pin types */
+#define VOLTAGE                1
+#define THERMISTOR     2
+#define PIIDIODE       3
+
+/*
+ * Conversion routines and macros.  Limit checking is only done on
+ * the TO_REG variants.
+ *
+ * Note that IN values are expressed as 100 times the actual voltage to avoid
+ * having to use floating point values.  As such, IN values are between 0 and
+ * 409 (0V to 4.096V).
+ */
+#define IN_TO_REG(val)         (SENSORS_LIMIT((((val) * 10 + 8) / 16), 0, 255))
+#define IN_FROM_REG(val)       (((val) * 16 + 5) / 10)
+
+/*
+ * The fan cotation count (as stored in the register) is calculated using the
+ * following formula:
+ *      count = (22.5K * 60) / (rpm * div) = 1350000 / (rpm * div)
+ * and the rpm is therefore:
+ *      rpm = 1350000 / (count * div)
+ */
+static inline u8 FAN_TO_REG(long rpm, int div)
+{
+       if (rpm == 0)
+               return 255;
+
+       rpm = SENSORS_LIMIT(rpm, 1, 1000000);
+
+       return SENSORS_LIMIT(
+                (1350000 + rpm * div / 2) / (rpm * div),
+                1, 254
+              );
+}
+
+#define FAN_FROM_REG(val, div) ((val) == 0 ? -1                              \
+                                           : (val) == 255 ? 0                \
+                                                          : 1350000 /        \
+                                                            ((val) * (div))  \
+                               )
+
+/*
+ * Temperatures are stored as two's complement values of the Celsius value.  It
+ * actually uses 10 times the Celsius value to avoid using floating point
+ * values.
+ */
+#define TEMP_TO_REG(val)       (                                             \
+                                (val) < 0                                    \
+                                   ? SENSORS_LIMIT(((val) - 5) / 10, 0, 255) \
+                                   : SENSORS_LIMIT(((val) + 5) / 10, 0, 255) \
+                               )
+#define TEMP_FROM_REG(val)     (                                             \
+                                (                                            \
+                                 (val) > 0x80 ? (val) - 0x100                \
+                                              : (val)                        \
+                                ) * 10                                       \
+                               )
+
+/*
+ * VCORE voltage:
+ *      0x00 to 0x0f    = 2.05 to 1.30 (0.05 per unit)
+ *      0x10 to 0x1e    = 3.50 to 2.10 (0.10 per unit)
+ *      0x1f            = No CPU
+ */
+#define VID_FROM_REG(val)      ((val) == 0x1f                                \
+                                        ? 0                                  \
+                                        : (val) < 0x10 ? 205 - (val) * 5     \
+                                                       : 510 - (val) * 10)
+
+/*
+ * Fan divider.
+ */
+#define DIV_FROM_REG(val)      (1 << (val))
+#define DIV_TO_REG(val)                ((val) == 8 ? 3                               \
+                                           : (val) == 4 ? 2                  \
+                                                        : (val) == 2 ? 1     \
+                                                                     : 0)
+
+/*
+ * Alarms (interrupt status).
+ */
+#define ALARMS_FROM_REG(val)   (val)
+
+/*
+ * Beep controls.
+ */
+#define BEEPS_FROM_REG(val)    (val)
+#define BEEPS_TO_REG(val)      (val)
+
+/*
+ * PWM control. nr range 1 to 3
+ */
+#define PWM_FROM_REG(val)      (val)
+#define PWM_TO_REG(val)                (val)
+#define PWMENABLE_FROM_REG(nr, val)    (((val) >> ((nr) + 3)) & 1)
+
+/*
+ * For each registered MTP008, we need to keep some data in memory.  The
+ * structure itself is dynamically allocated, at the same time when a new
+ * mtp008 client is allocated.
+ */
+struct mtp008_data {
+       struct i2c_client client;
+       int sysctl_id;
+       enum chips type;
+
+       struct semaphore update_lock;
+       char valid;                             /* !=0 if fields are valid */
+       unsigned long last_updated;             /* In jiffies */
+
+       u8 in[7];                               /* Register value */
+       u8 in_max[7];                           /* Register value */
+       u8 in_min[7];                           /* Register value */
+       u8 temp;                                /* Register value */
+       u8 temp_max;                            /* Register value */
+       u8 temp_min;                            /* Register value */
+       u8 fan[3];                              /* Register value */
+       u8 fan_min[3];                          /* Register value */
+       u8 vid;                                 /* Register encoding */
+       u8 fan_div[3];                          /* Register encoding */
+       u16 alarms;                             /* Register encoding */
+       u16 beeps;                              /* Register encoding */
+       u8 pwm[4];                              /* Register value */
+       u8 sens[3];                             /* 1 = Analog input,
+                                                  2 = Thermistor,
+                                                  3 = PII/Celeron diode */
+       u8 pwmenable;                           /* Register 0x57 value */
+};
+
+static int mtp008_attach_adapter(struct i2c_adapter *adapter);
+static int mtp008_detect(struct i2c_adapter *adapter, int address,
+                        unsigned short flags, int kind);
+static int mtp008_detach_client(struct i2c_client *client);
+
+static int mtp008_read_value(struct i2c_client *client, u8 register);
+static int mtp008_write_value(struct i2c_client *client, u8 register, u8 value);
+static void mtp008_update_client(struct i2c_client *client);
+static void mtp008_init_client(struct i2c_client *client);
+
+static void mtp008_in(struct i2c_client *client, int operation,
+                     int ctl_name, int *nrels_mag, long *results);
+static void mtp008_fan(struct i2c_client *client, int operation,
+                      int ctl_name, int *nrels_mag, long *results);
+static void mtp008_temp(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void mtp008_temp_add(struct i2c_client *client, int operation,
+                           int ctl_name, int *nrels_mag, long *results);
+static void mtp008_vid(struct i2c_client *client, int operation,
+                      int ctl_name, int *nrels_mag, long *results);
+static void mtp008_fan_div(struct i2c_client *client, int operation,
+                          int ctl_name, int *nrels_mag, long *results);
+static void mtp008_alarms(struct i2c_client *client, int operation,
+                         int ctl_name, int *nrels_mag, long *results);
+static void mtp008_beep(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void mtp008_pwm(struct i2c_client *client, int operation,
+                      int ctl_name, int *nrels_mag, long *results);
+static void mtp008_sens(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void mtp008_getsensortype(struct mtp008_data *data, u8 inp);
+
+static int mtp008_id = 0;
+
+static struct i2c_driver mtp008_driver =
+{
+       .owner          = THIS_MODULE,
+       .name           = "MTP008 sensor driver",
+       .id             = I2C_DRIVERID_MTP008,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = mtp008_attach_adapter,
+       .detach_client  = mtp008_detach_client,
+};
+
+/* -- SENSORS SYSCTL START -- */
+#define MTP008_SYSCTL_IN0      1000    /* Volts * 100 */
+#define MTP008_SYSCTL_IN1      1001
+#define MTP008_SYSCTL_IN2      1002
+#define MTP008_SYSCTL_IN3      1003
+#define MTP008_SYSCTL_IN4      1004
+#define MTP008_SYSCTL_IN5      1005
+#define MTP008_SYSCTL_IN6      1006
+#define MTP008_SYSCTL_FAN1     1101    /* Rotations/min */
+#define MTP008_SYSCTL_FAN2     1102
+#define MTP008_SYSCTL_FAN3     1103
+#define MTP008_SYSCTL_TEMP1    1200    /* Degrees Celcius * 10 */
+#define MTP008_SYSCTL_TEMP2    1201    /* Degrees Celcius * 10 */
+#define MTP008_SYSCTL_TEMP3    1202    /* Degrees Celcius * 10 */
+#define MTP008_SYSCTL_VID      1300    /* Volts * 100 */
+#define MTP008_SYSCTL_PWM1     1401
+#define MTP008_SYSCTL_PWM2     1402
+#define MTP008_SYSCTL_PWM3     1403
+#define MTP008_SYSCTL_SENS1    1501    /* 1, 2, or Beta (3000-5000) */
+#define MTP008_SYSCTL_SENS2    1502
+#define MTP008_SYSCTL_SENS3    1503
+#define MTP008_SYSCTL_FAN_DIV  2000    /* 1, 2, 4 or 8 */
+#define MTP008_SYSCTL_ALARMS   2001    /* bitvector */
+#define MTP008_SYSCTL_BEEP     2002    /* bitvector */
+
+#define MTP008_ALARM_IN0       0x0001
+#define MTP008_ALARM_IN1       0x0002
+#define MTP008_ALARM_IN2       0x0004
+#define MTP008_ALARM_IN3       0x0008
+#define MTP008_ALARM_IN4       0x0100
+#define MTP008_ALARM_IN5       0x0200
+#define MTP008_ALARM_IN6       0x0400
+#define MTP008_ALARM_FAN1      0x0040
+#define MTP008_ALARM_FAN2      0x0080
+#define MTP008_ALARM_FAN3      0x0800
+#define MTP008_ALARM_TEMP1     0x0010
+#define MTP008_ALARM_TEMP2     0x0100
+#define MTP008_ALARM_TEMP3     0x0200
+
+/* -- SENSORS SYSCTL END -- */
+
+/* The /proc/sys entries */
+/* These files are created for each detected chip. This is just a template;
+   though at first sight, you might think we could use a statically
+   allocated list, we need some way to get back to the parent - which
+   is done through one of the 'extra' fields which are initialized 
+   when a new copy is allocated. */
+
+static ctl_table mtp008_dir_table_template[] =
+{
+       {MTP008_SYSCTL_IN0, "in0", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &mtp008_in},
+       {MTP008_SYSCTL_IN1, "in1", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &mtp008_in},
+       {MTP008_SYSCTL_IN2, "in2", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &mtp008_in},
+       {MTP008_SYSCTL_IN3, "in3", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &mtp008_in},
+       {MTP008_SYSCTL_IN4, "in4", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &mtp008_in},
+       {MTP008_SYSCTL_IN5, "in5", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &mtp008_in},
+       {MTP008_SYSCTL_IN6, "in6", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &mtp008_in},
+       {MTP008_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &mtp008_fan},
+       {MTP008_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &mtp008_fan},
+       {MTP008_SYSCTL_FAN3, "fan3", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &mtp008_fan},
+       {MTP008_SYSCTL_TEMP1, "temp1", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &mtp008_temp},
+       {MTP008_SYSCTL_TEMP2, "temp2", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &mtp008_temp_add},
+       {MTP008_SYSCTL_TEMP3, "temp3", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &mtp008_temp_add},
+       {MTP008_SYSCTL_VID, "vid", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &mtp008_vid},
+       {MTP008_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &mtp008_fan_div},
+       {MTP008_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &mtp008_alarms},
+       {MTP008_SYSCTL_BEEP, "beep", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &mtp008_beep},
+       {MTP008_SYSCTL_PWM1, "pwm1", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &mtp008_pwm},
+       {MTP008_SYSCTL_PWM2, "pwm2", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &mtp008_pwm},
+       {MTP008_SYSCTL_PWM3, "pwm3", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &mtp008_pwm},
+       {MTP008_SYSCTL_SENS1, "sensor1", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &mtp008_sens},
+       {MTP008_SYSCTL_SENS2, "sensor2", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &mtp008_sens},
+       {MTP008_SYSCTL_SENS3, "sensor3", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &mtp008_sens},
+       {0}
+};
+
+/* This function is called when:
+ * mtp008_driver is inserted (when this module is loaded), for each available
+ * adapter when a new adapter is inserted (and mtp008_driver is still present)
+ */
+static int mtp008_attach_adapter(struct i2c_adapter *adapter)
+{
+       struct i2c_client_address_data mtp008_addr_data;
+
+       mtp008_addr_data.normal_i2c = addr_data.normal_i2c;
+       mtp008_addr_data.normal_i2c_range = addr_data.normal_i2c_range;
+       mtp008_addr_data.probe = addr_data.probe;
+       mtp008_addr_data.probe_range = addr_data.probe_range;
+       mtp008_addr_data.ignore = addr_data.ignore;
+       mtp008_addr_data.ignore_range = addr_data.ignore_range;
+       mtp008_addr_data.force = addr_data.forces->force;
+
+       return i2c_probe(adapter, &mtp008_addr_data, mtp008_detect);
+}
+
+int mtp008_detect(struct i2c_adapter *adapter, int address,
+                 unsigned short flags, int kind)
+{
+       const char *type_name = "";
+       const char *client_name = "";
+       int is_isa, err, sysid;
+       struct i2c_client *new_client;
+       struct mtp008_data *data;
+
+       err = 0;
+
+       is_isa = i2c_is_isa_adapter(adapter);
+       if (is_isa ||
+           !i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
+               goto ERROR0;
+
+       /*
+        * We presume we have a valid client.  We now create the client
+        * structure, even though we cannot fill it completely yet.  But it
+        * allows us to use mtp008_(read|write)_value().
+        */
+       if (!(data = kmalloc(sizeof(struct mtp008_data), GFP_KERNEL))) {
+               err = -ENOMEM;
+               goto ERROR0;
+       }
+
+       new_client = &data->client;
+       new_client->addr = address;
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &mtp008_driver;
+       new_client->flags = 0;
+
+       /*
+        * Remaining detection.
+        */
+       if (kind < 0) {
+               if (mtp008_read_value(new_client, MTP008_REG_CHIPID) != 0xac)
+                       goto ERROR1;
+       }
+       /*
+        * Fill in the remaining client fields and put it into the global list.
+        */
+       type_name = "mtp008";
+       client_name = "MTP008 chip";
+       strcpy(new_client->name, client_name);
+       data->type = kind;
+
+       new_client->id = mtp008_id++;
+       data->valid = 0;
+       init_MUTEX(&data->update_lock);
+
+       /*
+        * Tell the I2C layer that a new client has arrived.
+        */
+       if ((err = i2c_attach_client(new_client)))
+               goto ERROR1;
+
+       /*
+        * Register a new directory entry with the sensors module.
+        */
+       if ((sysid = i2c_register_entry(new_client, type_name,
+                                           mtp008_dir_table_template)) < 0) {
+               err = sysid;
+               goto ERROR2;
+       }
+       data->sysctl_id = sysid;
+
+       /*
+        * Initialize the MTP008 chip.
+        */
+       mtp008_init_client(new_client);
+
+       return 0;
+
+       /*
+        * Error handling.  Bad programming practise but very code efficient.
+        */
+      ERROR2:
+       i2c_detach_client(new_client);
+      ERROR1:
+       kfree(data);
+
+      ERROR0:
+       return err;
+}
+
+static int mtp008_detach_client(struct i2c_client *client)
+{
+       int err;
+
+       i2c_deregister_entry(
+               ((struct mtp008_data *) (client->data))->sysctl_id);
+
+       if ((err = i2c_detach_client(client))) {
+               printk("mtp008.o: Deregistration failed, "
+                      "client not detached.\n");
+               return err;
+       }
+       kfree(client->data);
+
+       return 0;
+}
+
+
+static int mtp008_read_value(struct i2c_client *client, u8 reg)
+{
+       return i2c_smbus_read_byte_data(client, reg) & 0xff;
+}
+
+static int mtp008_write_value(struct i2c_client *client, u8 reg, u8 value)
+{
+       return i2c_smbus_write_byte_data(client, reg, value);
+}
+
+/* Called when we have found a new MTP008. It should set limits, etc. */
+static void mtp008_init_client(struct i2c_client *client)
+{
+       u8 save1, save2;
+       struct mtp008_data *data;
+
+       data = client->data;
+
+       /*
+        * Initialize the Myson MTP008 hardware monitoring chip.
+        * Save the pin settings that the BIOS hopefully set.
+        */
+       save1 = mtp008_read_value(client, MTP008_REG_PIN_CTRL1);
+       save2 = mtp008_read_value(client, MTP008_REG_PIN_CTRL2);
+       mtp008_write_value(client, MTP008_REG_CONFIG,
+            (mtp008_read_value(client, MTP008_REG_CONFIG) & 0x7f) | 0x80);
+       mtp008_write_value(client, MTP008_REG_PIN_CTRL1, save1);
+       mtp008_write_value(client, MTP008_REG_PIN_CTRL2, save2);
+
+       mtp008_getsensortype(data, save2);
+
+
+       /*
+        * Start monitoring.
+        */
+       mtp008_write_value(
+               client, MTP008_REG_CONFIG,
+               (mtp008_read_value(client, MTP008_REG_CONFIG) & 0xf7) | 0x01
+       );
+}
+
+static void mtp008_update_client(struct i2c_client *client)
+{
+       int i;
+       u8 inp;
+       struct mtp008_data *data;
+
+       data = client->data;
+
+       down(&data->update_lock);
+
+       if ((jiffies - data->last_updated > HZ + HZ / 2) ||
+           (jiffies < data->last_updated) || !data->valid) {
+#ifdef DEBUG
+               printk("Starting MTP008 update\n");
+#endif
+
+               /*
+                * Read in the analog inputs.  We're reading AIN4 and AIN5 as
+                * regular analog inputs, even though they may have been
+                * configured as temperature readings instead.  Interpretation
+                * of these values is done elsewhere.
+                */
+               for (i = 0; i < 7; i++) {
+                       data->in[i] =
+                               mtp008_read_value(client, MTP008_REG_IN(i));
+                       data->in_max[i] =
+                               mtp008_read_value(client, MTP008_REG_IN_MAX(i));
+                       data->in_min[i] =
+                               mtp008_read_value(client, MTP008_REG_IN_MIN(i));
+               }
+
+               /*
+                * Read the temperature sensor.
+                */
+               data->temp = mtp008_read_value(client, MTP008_REG_TEMP);
+               data->temp_max = mtp008_read_value(client, MTP008_REG_TEMP_MAX);
+               data->temp_min = mtp008_read_value(client, MTP008_REG_TEMP_MIN);
+
+               /*
+                * Read the first 2 fan dividers and the VID setting.  Read the
+                * third fan divider from a different register.
+                */
+               inp = mtp008_read_value(client, MTP008_REG_VID_FANDIV);
+               data->vid = inp & 0x0f;
+               data->vid |= (mtp008_read_value(client,
+                                    MTP008_REG_RESET_VID4) & 0x01) << 4;
+
+               data->fan_div[0] = (inp >> 4) & 0x03;
+               data->fan_div[1] = inp >> 6;
+               data->fan_div[2] =
+                       mtp008_read_value(client, MTP008_REG_PIN_CTRL1) >> 6;
+
+               /*
+                * Read the interrupt status registers.
+                */
+               data->alarms =
+                       (mtp008_read_value(client,
+                                          MTP008_REG_INT_STAT1) & 0xdf) |
+                       (mtp008_read_value(client,
+                                          MTP008_REG_INT_STAT2) & 0x0f) << 8;
+
+               /*
+                * Read the beep control registers.
+                */
+               data->beeps =
+                       (mtp008_read_value(client,
+                                          MTP008_REG_BEEP_CTRL1) & 0xdf) |
+                       (mtp008_read_value(client,
+                                          MTP008_REG_BEEP_CTRL2) & 0x8f) << 8;
+
+               /*
+                * Read the sensor configuration.
+                */
+               inp = mtp008_read_value(client, MTP008_REG_PIN_CTRL2);
+               mtp008_getsensortype(data, inp);
+               data->pwmenable = inp;
+
+               /*
+                * Read the PWM registers if enabled.
+                */
+               for (i = 1; i <= 3; i++)
+               {
+                       if(PWMENABLE_FROM_REG(i, inp))
+                               data->pwm[i-1] = mtp008_read_value(client,
+                                                 MTP008_REG_PWM_CTRL(i));
+                       else
+                               data->pwm[i-1] = 255;
+               }
+
+               /*
+                * Read the fan sensors. Skip 3 if PWM1 enabled.
+                */
+               for (i = 1; i <= 3; i++) {
+                       if(i == 3 && PWMENABLE_FROM_REG(1, inp)) {
+                               data->fan[2] = 0;
+                               data->fan_min[2] = 0;
+                       } else {
+                               data->fan[i-1] = mtp008_read_value(client,
+                                         MTP008_REG_FAN(i));
+                               data->fan_min[i-1] = mtp008_read_value(client,
+                                         MTP008_REG_FAN_MIN(i));
+                       }
+               }
+
+               data->last_updated = jiffies;
+               data->valid = 1;
+       }
+       up(&data->update_lock);
+}
+
+static void mtp008_getsensortype(struct mtp008_data *data, u8 inp)
+{
+       inp &= 0x0f;
+       data->sens[0] = (inp >> 3) + 2;                 /* 2 or 3 */
+       data->sens[1] = ((inp >> 1) & 0x03) + 1;        /* 1, 2 or 3 */
+       data->sens[2] = (inp & 0x01) + 1;               /* 1 or 2 */
+}
+
+/* The next few functions are the call-back functions of the /proc/sys and
+   sysctl files. Which function is used is defined in the ctl_table in
+   the extra1 field.
+   Each function must return the magnitude (power of 10 to divide the date
+   with) if it is called with operation==SENSORS_PROC_REAL_INFO. It must
+   put a maximum of *nrels elements in results reflecting the data of this
+   file, and set *nrels to the number it actually put in it, if operation==
+   SENSORS_PROC_REAL_READ. Finally, it must get upto *nrels elements from
+   results and write them to the chip, if operations==SENSORS_PROC_REAL_WRITE.
+   Note that on SENSORS_PROC_REAL_READ, I do not check whether results is
+   large enough (by checking the incoming value of *nrels). This is not very
+   good practice, but as long as you put less than about 5 values in results,
+   you can assume it is large enough. */
+void mtp008_in(struct i2c_client *client, int operation, int ctl_name,
+              int *nrels_mag, long *results)
+{
+       int nr;
+       struct mtp008_data *data;
+
+       nr = ctl_name - MTP008_SYSCTL_IN0;
+       data = client->data;
+
+       switch (operation) {
+       case SENSORS_PROC_REAL_INFO:
+               *nrels_mag = 2;
+
+               break;
+       case SENSORS_PROC_REAL_READ:
+               mtp008_update_client(client);
+
+               if((nr != 4 && nr != 5) || data->sens[nr - 3] == VOLTAGE) {
+                       results[0] = IN_FROM_REG(data->in_min[nr]);
+                       results[1] = IN_FROM_REG(data->in_max[nr]);
+                       results[2] = IN_FROM_REG(data->in[nr]);
+               } else {
+                       results[0] = 0;
+                       results[1] = 0;
+                       results[2] = 0;
+               }
+
+               *nrels_mag = 3;
+
+               break;
+       case SENSORS_PROC_REAL_WRITE:
+               if((nr != 4 && nr != 5) || data->sens[nr - 3] == VOLTAGE) {
+                       if (*nrels_mag >= 1) {
+                               data->in_min[nr] = IN_TO_REG(results[0]);
+                               mtp008_write_value(client, MTP008_REG_IN_MIN(nr),
+                                                  data->in_min[nr]);
+                       }
+                       if (*nrels_mag >= 2) {
+                               data->in_max[nr] = IN_TO_REG(results[1]);
+                               mtp008_write_value(client, MTP008_REG_IN_MAX(nr),
+                                                  data->in_max[nr]);
+                       }
+               }
+       }
+}
+
+void mtp008_fan(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       int nr;
+       struct mtp008_data *data;
+
+       nr = ctl_name - MTP008_SYSCTL_FAN1;
+       data = client->data;
+
+       switch (operation) {
+       case SENSORS_PROC_REAL_INFO:
+               *nrels_mag = 0;
+
+               break;
+       case SENSORS_PROC_REAL_READ:
+               mtp008_update_client(client);
+
+               results[0] = FAN_FROM_REG(data->fan_min[nr],
+                                       DIV_FROM_REG(data->fan_div[nr]));
+               results[1] = FAN_FROM_REG(data->fan[nr],
+                                       DIV_FROM_REG(data->fan_div[nr]));
+
+               *nrels_mag = 2;
+
+               break;
+       case SENSORS_PROC_REAL_WRITE:
+               if (*nrels_mag >= 1) {
+                       data->fan_min[nr] =
+                           FAN_TO_REG(results[0],
+                                      DIV_FROM_REG(data->fan_div[nr]));
+                       mtp008_write_value(client, MTP008_REG_FAN_MIN(nr + 1),
+                                          data->fan_min[nr]);
+               }
+       }
+}
+
+void mtp008_temp(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct mtp008_data *data;
+
+       data = client->data;
+
+       switch (operation) {
+       case SENSORS_PROC_REAL_INFO:
+               *nrels_mag = 1;
+
+               break;
+       case SENSORS_PROC_REAL_READ:
+               mtp008_update_client(client);
+
+               results[0] = TEMP_FROM_REG(data->temp_max);
+               results[1] = TEMP_FROM_REG(data->temp_min);
+               results[2] = TEMP_FROM_REG(data->temp);
+               *nrels_mag = 3;
+
+               break;
+       case SENSORS_PROC_REAL_WRITE:
+               if (*nrels_mag >= 1) {
+                       data->temp_max = TEMP_TO_REG(results[0]);
+                       mtp008_write_value(client, MTP008_REG_TEMP_MAX,
+                                          data->temp_max);
+               }
+               if (*nrels_mag >= 2) {
+                       data->temp_min = TEMP_TO_REG(results[1]);
+                       mtp008_write_value(client, MTP008_REG_TEMP_MIN,
+                                          data->temp_min);
+               }
+       }
+}
+
+void mtp008_temp_add(struct i2c_client *client, int operation, int ctl_name,
+                    int *nrels_mag, long *results)
+{
+       int nr;
+       struct mtp008_data *data;
+
+       nr = 3 + ctl_name - MTP008_SYSCTL_TEMP1;        /* AIN4 or AIN5 */
+       data = client->data;
+
+       switch (operation) {
+       case SENSORS_PROC_REAL_INFO:
+               *nrels_mag = 1;
+
+               break;
+       case SENSORS_PROC_REAL_READ:
+               mtp008_update_client(client);
+
+               if(data->sens[nr - 3] != VOLTAGE) {
+                       results[0] = TEMP_FROM_REG(data->in_max[nr]);
+                       results[1] = TEMP_FROM_REG(data->in_min[nr]);
+                       results[2] = TEMP_FROM_REG(data->in[nr]);
+               } else {
+                       results[0] = 0;
+                       results[1] = 0;
+                       results[2] = 0;
+               }
+               *nrels_mag = 3;
+
+               break;
+       case SENSORS_PROC_REAL_WRITE:
+               if(data->sens[nr - 3] != VOLTAGE) {
+                       if (*nrels_mag >= 1) {
+                               data->in_max[nr] = TEMP_TO_REG(results[0]);
+                               mtp008_write_value(client,
+                                                  MTP008_REG_IN_MAX(nr),
+                                                  data->in_max[nr]);
+                       }
+                       if (*nrels_mag >= 2) {
+                               data->in_min[nr] = TEMP_TO_REG(results[1]);
+                               mtp008_write_value(client,
+                                                  MTP008_REG_IN_MIN(nr),
+                                                  data->in_min[nr]);
+                       }
+               }
+       }
+}
+
+void mtp008_vid(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       struct mtp008_data *data;
+
+       data = client->data;
+
+       switch (operation) {
+       case SENSORS_PROC_REAL_INFO:
+               *nrels_mag = 2;
+
+               break;
+       case SENSORS_PROC_REAL_READ:
+               mtp008_update_client(client);
+
+               results[0] = VID_FROM_REG(data->vid);
+
+               *nrels_mag = 1;
+       }
+}
+
+void mtp008_fan_div(struct i2c_client *client, int operation,
+                   int ctl_name, int *nrels_mag, long *results)
+{
+       struct mtp008_data *data;
+       u8 val;
+
+       data = client->data;
+
+       switch (operation) {
+       case SENSORS_PROC_REAL_INFO:
+               *nrels_mag = 0;
+
+               break;
+       case SENSORS_PROC_REAL_READ:
+               mtp008_update_client(client);
+
+               results[0] = DIV_FROM_REG(data->fan_div[0]);
+               results[1] = DIV_FROM_REG(data->fan_div[1]);
+               results[2] = DIV_FROM_REG(data->fan_div[2]);
+
+               *nrels_mag = 3;
+
+               break;
+       case SENSORS_PROC_REAL_WRITE:
+               if (*nrels_mag >= 3) {
+                       data->fan_div[2] = DIV_TO_REG(results[2]);
+                       val = mtp008_read_value(client, MTP008_REG_PIN_CTRL1);
+                       val = (val & 0x3f) | (data->fan_div[2] & 0x03) << 6;
+                       mtp008_write_value(client, MTP008_REG_PIN_CTRL1, val);
+               }
+               if (*nrels_mag >= 1) {
+                       val = mtp008_read_value(client, MTP008_REG_VID_FANDIV);
+                       if (*nrels_mag >= 2) {
+                               data->fan_div[1] = DIV_TO_REG(results[1]);
+                               val = (val & 0x3f) |
+                                     (data->fan_div[1] & 0x03) << 6;
+                       }
+                       data->fan_div[0] = DIV_TO_REG(results[0]);
+                       val = (val & 0xcf) | (data->fan_div[0] & 0x03) << 4;
+                       mtp008_write_value(client, MTP008_REG_VID_FANDIV, val);
+               }
+       }
+}
+
+void mtp008_alarms(struct i2c_client *client, int operation, int ctl_name,
+                  int *nrels_mag, long *results)
+{
+       struct mtp008_data *data;
+
+       data = client->data;
+
+       switch (operation) {
+       case SENSORS_PROC_REAL_INFO:
+               *nrels_mag = 0;
+
+               break;
+       case SENSORS_PROC_REAL_READ:
+               mtp008_update_client(client);
+
+               results[0] = ALARMS_FROM_REG(data->alarms);
+
+               *nrels_mag = 1;
+       }
+}
+
+void mtp008_beep(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct mtp008_data *data;
+
+       data = client->data;
+
+       switch (operation) {
+       case SENSORS_PROC_REAL_INFO:
+               *nrels_mag = 0;
+
+               break;
+       case SENSORS_PROC_REAL_READ:
+               mtp008_update_client(client);
+
+               results[0] = BEEPS_FROM_REG(data->beeps);
+
+               *nrels_mag = 1;
+
+               break;
+       case SENSORS_PROC_REAL_WRITE:
+               if (*nrels_mag >= 1) {
+                       data->beeps = BEEPS_TO_REG(results[0]) & 0xdf8f;
+
+                       mtp008_write_value(client, MTP008_REG_BEEP_CTRL1,
+                                          data->beeps & 0xff);
+                       mtp008_write_value(client, MTP008_REG_BEEP_CTRL2,
+                                          data->beeps >> 8);
+               }
+       }
+}
+
+void mtp008_pwm(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       int nr;
+       struct mtp008_data *data;
+
+       nr = ctl_name - MTP008_SYSCTL_PWM1;
+       data = client->data;
+
+       switch (operation) {
+       case SENSORS_PROC_REAL_INFO:
+               *nrels_mag = 0;
+
+               break;
+       case SENSORS_PROC_REAL_READ:
+               mtp008_update_client(client);
+
+               results[0] = PWM_FROM_REG(data->pwm[nr]);
+               results[1] = PWMENABLE_FROM_REG(nr + 1, data->pwmenable);
+               *nrels_mag = 2;
+
+               break;
+       case SENSORS_PROC_REAL_WRITE:
+               if (*nrels_mag >= 1) {
+                       if (*nrels_mag >= 2) {
+                               if(results[1])
+                                       data->pwmenable |= 0x10 << nr;
+                               else
+                                       data->pwmenable &= ~(0x10 << nr);
+                               mtp008_write_value(client, MTP008_REG_PIN_CTRL2,
+                                                  data->pwmenable);
+                       }
+                       data->pwm[nr] = PWM_TO_REG(results[0]);
+                       mtp008_write_value(client, MTP008_REG_PWM_CTRL(nr),
+                                          data->pwm[nr]);
+               }
+       }
+}
+
+void mtp008_sens(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       const char *opts = "";
+       int nr;
+       u8 tmp;
+       struct mtp008_data *data;
+
+       nr = 1 + ctl_name - MTP008_SYSCTL_SENS1;
+       data = client->data;
+
+       switch (operation) {
+       case SENSORS_PROC_REAL_INFO:
+               *nrels_mag = 0;
+
+               break;
+       case SENSORS_PROC_REAL_READ:
+               results[0] = data->sens[nr - 1];
+
+               *nrels_mag = 1;
+
+               break;
+       case SENSORS_PROC_REAL_WRITE:
+               if (*nrels_mag >= 1) {
+                       tmp = mtp008_read_value(client, MTP008_REG_PIN_CTRL2);
+
+                       switch (nr) {
+                       case 1: /* VT or PII */
+                               opts = "2 or 3";
+
+                               switch (results[0]) {
+                               case THERMISTOR:
+                                       mtp008_write_value(
+                                               client, MTP008_REG_PIN_CTRL2,
+                                               tmp & ~MTP008_CFG_VT1_PII);
+                                       data->sens[0] = 2;
+                                       return;
+                               case PIIDIODE:
+                                       mtp008_write_value(
+                                               client, MTP008_REG_PIN_CTRL2,
+                                               tmp | MTP008_CFG_VT1_PII);
+                                       data->sens[0] = 3;
+                                       return;
+                               }
+
+                               break;
+                       case 2: /* AIN, VT or PII */
+                               tmp &= ~MTP008_CFG_VT2_MASK;
+                               opts = "1, 2 or 3";
+
+                               switch (results[0]) {
+                               case VOLTAGE:
+                                       mtp008_write_value(
+                                               client, MTP008_REG_PIN_CTRL2,
+                                               tmp | MTP008_CFG_VT2_AIN);
+                                       data->sens[1] = 1;
+                                       return;
+                               case THERMISTOR:
+                                       mtp008_write_value(
+                                               client, MTP008_REG_PIN_CTRL2,
+                                               tmp | MTP008_CFG_VT2_VT);
+                                       data->sens[1] = 2;
+                                       return;
+                               case PIIDIODE:
+                                       mtp008_write_value(
+                                               client, MTP008_REG_PIN_CTRL2,
+                                               tmp | MTP008_CFG_VT2_PII);
+                                       data->sens[1] = 3;
+                                       return;
+                               }
+
+                               break;
+                       case 3: /* AIN or VT */
+                               opts = "1 or 2";
+
+                               switch (results[0]) {
+                               case VOLTAGE:
+                                       mtp008_write_value(
+                                               client, MTP008_REG_PIN_CTRL2,
+                                               tmp & ~MTP008_CFG_VT3_VT);
+                                       data->sens[2] = 1;
+                                       return;
+                               case THERMISTOR:
+                                       mtp008_write_value(
+                                               client, MTP008_REG_PIN_CTRL2,
+                                               tmp | MTP008_CFG_VT3_VT);
+                                       data->sens[2] = 2;
+                                       return;
+                               }
+
+                               break;
+                       }
+
+                       printk("mtp008.o: Invalid sensor type %ld "
+                              "for sensor %d; must be %s.\n",
+                              results[0], nr, opts);
+               }
+       }
+}
+
+static int __init sm_mtp008_init(void)
+{
+       printk("mtp008.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       return i2c_add_driver(&mtp008_driver);
+}
+
+static void __exit sm_mtp008_exit(void)
+{
+       i2c_del_driver(&mtp008_driver);
+}
+
+
+
+MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>, "
+             "Philip Edelbrock <phil@netroedge.com>, "
+             "and Kris Van Hees <aedil@alchar.org>");
+MODULE_DESCRIPTION("MTP008 driver");
+
+module_init(sm_mtp008_init);
+module_exit(sm_mtp008_exit);
--- linux-old/drivers/sensors/pc87360.c Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/pc87360.c     Mon Dec 13 20:18:51 2004
@@ -0,0 +1,1357 @@
+/*
+ *  pc87360.c - Part of lm_sensors, Linux kernel modules
+ *              for hardware monitoring
+ *  Copyright (C) 2004 Jean Delvare <khali@linux-fr.org> 
+ *
+ *  Copied from smsc47m1.c:
+ *  Copyright (C) 2002 Mark D. Studebaker <mdsxyz123@yahoo.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *  Supports the following chips:
+ *
+ *  Chip        #vin    #fan    #pwm    #temp   devid
+ *  PC87360     -       2       2       -       0xE1
+ *  PC87363     -       2       2       -       0xE8
+ *  PC87364     -       3       3       -       0xE4
+ *  PC87365     11      3       3       2       0xE5
+ *  PC87366     11      3       3       3-4     0xE9
+ *
+ *  This driver assumes that no more than one chip is present, and the
+ *  standard Super-I/O address is used (0x2E/0x2F).
+ */
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/ioport.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#include <asm/io.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+#include <linux/sensors_vid.h>
+
+static unsigned short normal_i2c[] = { SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { SENSORS_I2C_END };
+static unsigned int normal_isa[] = { 0x0000, SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+static struct i2c_force_data forces[] = {{NULL}};
+static u8 devid;
+static unsigned int extra_isa[] = { 0x0000, 0x0000, 0x0000 };
+static u8 confreg[4];
+
+enum chips { any_chip, pc87360, pc87363, pc87364, pc87365, pc87366 };
+static struct i2c_address_data addr_data = {
+       .normal_i2c             = normal_i2c,
+       .normal_i2c_range       = normal_i2c_range,
+       .normal_isa             = normal_isa,
+       .normal_isa_range       = normal_isa_range,
+       .probe                  = normal_i2c,           /* cheat */
+       .probe_range            = normal_i2c_range,     /* cheat */
+       .ignore                 = normal_i2c,           /* cheat */
+       .ignore_range           = normal_i2c_range,     /* cheat */
+       .forces                 = forces,
+};
+
+static int init = 1;
+MODULE_PARM(init, "i");
+MODULE_PARM_DESC(init,
+       "Chip initialization level:\n"
+       " 0: None\n"
+       "*1: Forcibly enable internal voltage and temperature channels, except in9\n"
+       " 2: Forcibly enable all voltage and temperature channels, except in9\n"
+       " 3: Forcibly enable all voltage and temperature channels, including in9");
+
+/*
+ * Super-I/O registers and operations
+ */
+
+#define REG    0x2e    /* The register to read/write */
+#define VAL    0x2f    /* The value to read/write */
+
+#define DEV    0x07    /* Register: Logical device select */
+#define DEVID  0x20    /* Register: Device ID */
+#define ACT    0x30    /* Register: Device activation */
+#define BASE   0x60    /* Register: Base address */
+
+#define FSCM   0x09    /* Logical device: fans */
+#define VLM    0x0d    /* Logical device: voltages */
+#define TMS    0x0e    /* Logical device: temperatures */
+static const u8 logdev[3] = { FSCM, VLM, TMS };
+
+#define LD_FAN         0
+#define LD_IN          1
+#define LD_TEMP                2
+
+static inline void superio_outb(int reg, int val)
+{
+       outb(reg, REG);
+       outb(val, VAL);
+}
+
+static inline int superio_inb(int reg)
+{
+       outb(reg, REG);
+       return inb(VAL);
+}
+
+static inline void superio_exit(void)
+{
+       outb(0x02, REG);
+       outb(0x02, VAL);
+}
+
+/*
+ * Logical devices
+ */
+
+#define PC87360_EXTENT         0x10
+#define PC87365_REG_BANK       0x09
+#define NO_BANK                        0xff
+
+/*
+ * Fan registers and conversions
+ */
+
+/* nr has to be 0 or 1 (PC87360/87363) or 2 (PC87364/87365/87366) */
+#define PC87360_REG_PRESCALE(nr)       (0x00 + 2 * (nr))
+#define PC87360_REG_PWM(nr)            (0x01 + 2 * (nr))
+#define PC87360_REG_FAN_MIN(nr)                (0x06 + 3 * (nr))
+#define PC87360_REG_FAN(nr)            (0x07 + 3 * (nr))
+#define PC87360_REG_FAN_STATUS(nr)     (0x08 + 3 * (nr))
+
+#define FAN_FROM_REG(val,div)          ((val)==0?0: \
+                                        480000/((val)*(div)))
+#define FAN_TO_REG(val,div)            ((val)<=100?0: \
+                                        480000/((val)*(div)))
+#define FAN_DIV_FROM_REG(val)          (1 << ((val >> 5) & 0x03))
+#define FAN_DIV_TO_REG(val)            ((val)==8?0x60:(val)==4?0x40: \
+                                        (val)==1?0x00:0x20)
+#define FAN_STATUS_FROM_REG(val)       ((val) & 0x07)
+
+#define FAN_CONFIG_MONITOR(val,nr)     (((val) >> (2 + nr * 3)) & 1)
+#define FAN_CONFIG_CONTROL(val,nr)     (((val) >> (3 + nr * 3)) & 1)
+#define FAN_CONFIG_INVERT(val,nr)      (((val) >> (4 + nr * 3)) & 1)
+
+#define PWM_FROM_REG(val,inv)          ((inv) ? 255 - (val) : (val))
+static inline u8 PWM_TO_REG(int val, int inv)
+{
+       if (inv)
+               val = 255 - val;
+       if (val < 0)
+               return 0;
+       if (val > 255)
+               return 255;
+       return val;
+}
+
+/*
+ * Voltage registers and conversions
+ */
+
+#define PC87365_REG_IN_CONVRATE                0x07
+#define PC87365_REG_IN_CONFIG          0x08
+#define PC87365_REG_IN                 0x0B
+#define PC87365_REG_IN_MIN             0x0D
+#define PC87365_REG_IN_MAX             0x0C
+#define PC87365_REG_IN_STATUS          0x0A
+#define PC87365_REG_IN_ALARMS1         0x00
+#define PC87365_REG_IN_ALARMS2         0x01
+#define PC87365_REG_VID                        0x06
+
+#define IN_FROM_REG(val,ref)           (((val) * (ref) + 128) / 256)
+#define IN_TO_REG(val,ref)             ((val)<0 ? 0 : \
+                                        (val)*256>=(ref)*255 ? 255: \
+                                        ((val) * 256 + (ref) / 2) / (ref))
+
+/*
+ * Temperature registers and conversions
+ */
+
+#define PC87365_REG_TEMP_CONFIG                0x08
+#define PC87365_REG_TEMP               0x0B
+#define PC87365_REG_TEMP_MIN           0x0D
+#define PC87365_REG_TEMP_MAX           0x0C
+#define PC87365_REG_TEMP_CRIT          0x0E
+#define PC87365_REG_TEMP_STATUS                0x0A
+#define PC87365_REG_TEMP_ALARMS                0x00
+
+#define TEMP_FROM_REG(val)             ((val)&0x80 ? (val) - 0x100 : (val))
+#define TEMP_TO_REG(val)               ((val)<-55 ? 201 : (val)>127 ? 0x7F : \
+                                        (val)<0 ? (val) + 0x100 : (val))
+
+struct pc87360_data {
+       struct i2c_client client;
+       struct semaphore lock;
+       int sysctl_id;
+       int address[3];
+
+       struct semaphore update_lock;
+       char valid;             /* !=0 if following fields are valid */
+       unsigned long last_updated;     /* In jiffies */
+
+       u8 fannr, innr, tempnr;
+
+       u8 fan[3];              /* Register value */
+       u8 fan_min[3];          /* Register value */
+       u8 fan_status[3];       /* Register value */
+       u8 pwm[3];              /* Register value */
+       u16 fan_conf;           /* Configuration register values, combined */
+
+       u16 in_vref;            /* 10mV/bit */
+       u8 in[14];              /* Register value */
+       u8 in_min[14];          /* Register value */
+       u8 in_max[14];          /* Register value */
+       u8 in_crit[3];          /* Register value */
+       u8 in_status[14];       /* Register value */
+       u16 in_alarms;          /* Register values, combined, masked */
+       u8 vid_conf;            /* Configuration register value */
+       u8 vrm;
+       u8 vid;                 /* Register value */
+
+       u8 temp[3];             /* Register value */
+       u8 temp_min[3];         /* Register value */
+       u8 temp_max[3];         /* Register value */
+       u8 temp_crit[3];        /* Register value */
+       u8 temp_status[3];      /* Register value */
+       u8 temp_alarms;         /* Register value, masked */
+};
+
+
+static int pc87360_attach_adapter(struct i2c_adapter *adapter);
+static int pc87360_detect(struct i2c_adapter *adapter, int address,
+                         unsigned short flags, int kind);
+static int pc87360_detach_client(struct i2c_client *client);
+
+static int pc87360_read_value(struct pc87360_data *data, u8 ldi, u8 bank,
+                             u8 reg);
+static void pc87360_write_value(struct pc87360_data *data, u8 ldi, u8 bank,
+                               u8 reg, u8 value);
+static void pc87360_init_client(struct i2c_client *client, int use_thermistors);
+static void pc87360_update_client(struct i2c_client *client);
+static int pc87360_find(u8 *devid, int *address);
+
+
+void pc87365_alarms(struct i2c_client *client, int operation, int ctl_name,
+                   int *nrels_mag, long *results);
+
+static void pc87360_fan(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void pc87360_fan_status(struct i2c_client *client, int operation,
+                              int ctl_name, int *nrels_mag, long *results);
+static void pc87360_fan_div(struct i2c_client *client, int operation,
+                           int ctl_name, int *nrels_mag, long *results);
+static void pc87360_pwm(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+
+void pc87365_in(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results);
+void pc87365_in_status(struct i2c_client *client, int operation, int ctl_name,
+                      int *nrels_mag, long *results);
+void pc87365_vid(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results);
+void pc87365_vrm(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results);
+
+void pc87365_temp(struct i2c_client *client, int operation, int ctl_name,
+                 int *nrels_mag, long *results);
+void pc87365_temp_status(struct i2c_client *client, int operation, int ctl_name,
+                        int *nrels_mag, long *results);
+
+static int pc87360_id = 0;
+
+static struct i2c_driver pc87360_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "PC8736x hardware monitor",
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = pc87360_attach_adapter,
+       .detach_client  = pc87360_detach_client,
+};
+
+/* -- SENSORS SYSCTL START -- */
+
+#define PC87365_SYSCTL_ALARMS          100 /* bit field */
+
+#define PC87360_SYSCTL_FAN1            1101 /* Rotations/min */
+#define PC87360_SYSCTL_FAN2            1102
+#define PC87360_SYSCTL_FAN3            1103 /* not for PC87360/PC87363 */
+#define PC87360_SYSCTL_FAN_DIV         1201 /* 1, 2, 4 or 8 */
+#define PC87360_SYSCTL_FAN1_STATUS     1301 /* bit field */
+#define PC87360_SYSCTL_FAN2_STATUS     1302
+#define PC87360_SYSCTL_FAN3_STATUS     1303 /* not for PC87360/PC87363 */
+#define PC87360_SYSCTL_PWM1            1401 /* 0-255 */
+#define PC87360_SYSCTL_PWM2            1402
+#define PC87360_SYSCTL_PWM3            1403 /* not for PC87360/PC87363 */
+
+#define PC87360_STATUS_FAN_READY       0x01
+#define PC87360_STATUS_FAN_LOW         0x02
+#define PC87360_STATUS_FAN_OVERFLOW    0x04
+
+#define PC87365_SYSCTL_IN0             2100 /* mV */
+#define PC87365_SYSCTL_IN1             2101
+#define PC87365_SYSCTL_IN2             2102
+#define PC87365_SYSCTL_IN3             2103
+#define PC87365_SYSCTL_IN4             2104
+#define PC87365_SYSCTL_IN5             2105
+#define PC87365_SYSCTL_IN6             2106
+#define PC87365_SYSCTL_IN7             2107
+#define PC87365_SYSCTL_IN8             2108
+#define PC87365_SYSCTL_IN9             2109
+#define PC87365_SYSCTL_IN10            2110
+#define PC87365_SYSCTL_TEMP4           2111 /* not for PC87365 */
+#define PC87365_SYSCTL_TEMP5           2112 /* not for PC87365 */
+#define PC87365_SYSCTL_TEMP6           2113 /* not for PC87365 */
+#define PC87365_SYSCTL_IN0_STATUS      2300 /* bit field */
+#define PC87365_SYSCTL_IN1_STATUS      2301
+#define PC87365_SYSCTL_IN2_STATUS      2302
+#define PC87365_SYSCTL_IN3_STATUS      2303
+#define PC87365_SYSCTL_IN4_STATUS      2304
+#define PC87365_SYSCTL_IN5_STATUS      2305
+#define PC87365_SYSCTL_IN6_STATUS      2306
+#define PC87365_SYSCTL_IN7_STATUS      2307
+#define PC87365_SYSCTL_IN8_STATUS      2308
+#define PC87365_SYSCTL_IN9_STATUS      2309
+#define PC87365_SYSCTL_IN10_STATUS     2310
+#define PC87365_SYSCTL_TEMP4_STATUS    2311 /* not for PC87365 */
+#define PC87365_SYSCTL_TEMP5_STATUS    2312 /* not for PC87365 */
+#define PC87365_SYSCTL_TEMP6_STATUS    2313 /* not for PC87365 */
+
+#define PC87365_SYSCTL_VID             2400
+#define PC87365_SYSCTL_VRM             2401
+
+#define PC87365_STATUS_IN_MIN          0x02
+#define PC87365_STATUS_IN_MAX          0x04
+
+#define PC87365_SYSCTL_TEMP1           3101 /* degrees Celcius */
+#define PC87365_SYSCTL_TEMP2           3102
+#define PC87365_SYSCTL_TEMP3           3103 /* not for PC87365 */
+#define PC87365_SYSCTL_TEMP1_STATUS    3301 /* bit field */
+#define PC87365_SYSCTL_TEMP2_STATUS    3302
+#define PC87365_SYSCTL_TEMP3_STATUS    3303 /* not for PC87365 */
+
+#define PC87365_STATUS_TEMP_MIN                0x02
+#define PC87365_STATUS_TEMP_MAX                0x04
+#define PC87365_STATUS_TEMP_CRIT       0x08
+#define PC87365_STATUS_TEMP_OPEN       0x40
+
+/* -- SENSORS SYSCTL END -- */
+
+static ctl_table pc87360_dir_table_template[] = { /* PC87363 and PC87364 too */
+       {PC87360_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87360_fan},
+       {PC87360_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87360_fan},
+       {PC87360_SYSCTL_FAN3, "fan3", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87360_fan},
+       {PC87360_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87360_fan_div},
+       {PC87360_SYSCTL_FAN1_STATUS, "fan1_status", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87360_fan_status},
+       {PC87360_SYSCTL_FAN2_STATUS, "fan2_status", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87360_fan_status},
+       {PC87360_SYSCTL_FAN3_STATUS, "fan3_status", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87360_fan_status},
+       {PC87360_SYSCTL_PWM1, "pwm1", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87360_pwm},
+       {PC87360_SYSCTL_PWM2, "pwm2", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87360_pwm},
+       {PC87360_SYSCTL_PWM3, "pwm3", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87360_pwm},
+       {0}
+};
+
+static ctl_table pc87365_dir_table_template[] = { /* PC87366 too */
+       {PC87365_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_alarms},
+       {PC87360_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87360_fan},
+       {PC87360_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87360_fan},
+       {PC87360_SYSCTL_FAN3, "fan3", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87360_fan},
+       {PC87360_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87360_fan_div},
+       {PC87360_SYSCTL_FAN1_STATUS, "fan1_status", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87360_fan_status},
+       {PC87360_SYSCTL_FAN2_STATUS, "fan2_status", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87360_fan_status},
+       {PC87360_SYSCTL_FAN3_STATUS, "fan3_status", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87360_fan_status},
+       {PC87360_SYSCTL_PWM1, "pwm1", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87360_pwm},
+       {PC87360_SYSCTL_PWM2, "pwm2", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87360_pwm},
+       {PC87360_SYSCTL_PWM3, "pwm3", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87360_pwm},
+       {PC87365_SYSCTL_IN0, "in0", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_in},
+       {PC87365_SYSCTL_IN1, "in1", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_in},
+       {PC87365_SYSCTL_IN2, "in2", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_in},
+       {PC87365_SYSCTL_IN3, "in3", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_in},
+       {PC87365_SYSCTL_IN4, "in4", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_in},
+       {PC87365_SYSCTL_IN5, "in5", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_in},
+       {PC87365_SYSCTL_IN6, "in6", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_in},
+       {PC87365_SYSCTL_IN7, "in7", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_in},
+       {PC87365_SYSCTL_IN8, "in8", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_in},
+       {PC87365_SYSCTL_IN9, "in9", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_in},
+       {PC87365_SYSCTL_IN10, "in10", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_in},
+       {PC87365_SYSCTL_IN0_STATUS, "in0_status", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_in_status},
+       {PC87365_SYSCTL_IN1_STATUS, "in1_status", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_in_status},
+       {PC87365_SYSCTL_IN2_STATUS, "in2_status", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_in_status},
+       {PC87365_SYSCTL_IN3_STATUS, "in3_status", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_in_status},
+       {PC87365_SYSCTL_IN4_STATUS, "in4_status", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_in_status},
+       {PC87365_SYSCTL_IN5_STATUS, "in5_status", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_in_status},
+       {PC87365_SYSCTL_IN6_STATUS, "in6_status", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_in_status},
+       {PC87365_SYSCTL_IN7_STATUS, "in7_status", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_in_status},
+       {PC87365_SYSCTL_IN8_STATUS, "in8_status", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_in_status},
+       {PC87365_SYSCTL_IN9_STATUS, "in9_status", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_in_status},
+       {PC87365_SYSCTL_IN10_STATUS, "in10_status", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_in_status},
+       {PC87365_SYSCTL_TEMP1, "temp1", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_temp},
+       {PC87365_SYSCTL_TEMP2, "temp2", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_temp},
+       {PC87365_SYSCTL_TEMP3, "temp3", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_temp},
+       {PC87365_SYSCTL_TEMP4, "temp4", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_in},
+       {PC87365_SYSCTL_TEMP5, "temp5", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_in},
+       {PC87365_SYSCTL_TEMP6, "temp6", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_in},
+       {PC87365_SYSCTL_TEMP1_STATUS, "temp1_status", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_temp_status},
+       {PC87365_SYSCTL_TEMP2_STATUS, "temp2_status", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_temp_status},
+       {PC87365_SYSCTL_TEMP3_STATUS, "temp3_status", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_temp_status},
+       {PC87365_SYSCTL_TEMP4_STATUS, "temp4_status", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_in_status},
+       {PC87365_SYSCTL_TEMP5_STATUS, "temp5_status", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_in_status},
+       {PC87365_SYSCTL_TEMP6_STATUS, "temp6_status", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_in_status},
+       {PC87365_SYSCTL_VID, "vid", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_vid},
+       {PC87365_SYSCTL_VRM, "vrm", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &pc87365_vrm},
+       {0}
+};
+
+static int pc87360_attach_adapter(struct i2c_adapter *adapter)
+{
+       return i2c_detect(adapter, &addr_data, pc87360_detect);
+}
+
+static int pc87360_find(u8 *devid, int *address)
+{
+       u16 val;
+       int i;
+       int nrdev; /* logical device count */
+
+       /* No superio_enter */
+
+       /* Identify device */
+       val = superio_inb(DEVID);
+       switch (val) {
+       case 0xE1: /* PC87360 */
+       case 0xE8: /* PC87363 */
+       case 0xE4: /* PC87364 */
+               nrdev = 1;
+               break;
+       case 0xE5: /* PC87365 */
+       case 0xE9: /* PC87366 */
+               nrdev = 3;
+               break;
+       default:
+               superio_exit();
+               return -ENODEV;
+       }
+       /* Remember the device id */
+       *devid = val;
+
+       for (i = 0; i < nrdev; i++) {
+               /* select logical device */
+               superio_outb(DEV, logdev[i]);
+
+               val = superio_inb(ACT);
+               if (!(val & 0x01)) {
+                       printk(KERN_INFO "pc87360.o: Device 0x%02x not "
+                              "activated\n", logdev[i]);
+                       continue;
+               }
+
+               val = (superio_inb(BASE) << 8)
+                   | superio_inb(BASE + 1);
+               if (!val) {
+                       printk(KERN_INFO "pc87360.o: Base address not set for "
+                              "device 0x%02x\n", logdev[i]);
+                       continue;
+               }
+
+               address[i] = val;
+
+               if (i==0) { /* Fans */
+                       confreg[0] = superio_inb(0xF0);
+                       confreg[1] = superio_inb(0xF1);
+                       
+#ifdef DEBUG
+                       printk(KERN_DEBUG "pc87360.o: Fan 1: mon=%d "
+                              "ctrl=%d inv=%d\n", (confreg[0]>>2)&1,
+                              (confreg[0]>>3)&1, (confreg[0]>>4)&1);
+                       printk(KERN_DEBUG "pc87360.o: Fan 2: mon=%d "
+                              "ctrl=%d inv=%d\n", (confreg[0]>>5)&1,
+                              (confreg[0]>>6)&1, (confreg[0]>>7)&1);
+                       printk(KERN_DEBUG "pc87360.o: Fan 3: mon=%d "
+                              "ctrl=%d inv=%d\n", confreg[1]&1,
+                              (confreg[1]>>1)&1, (confreg[1]>>2)&1);
+#endif
+               } else if (i==1) { /* Voltages */
+                       /* Are we using thermistors? */
+                       if (*devid == 0xE9) { /* PC87366 */
+                               /* These registers are not logical-device
+                                  specific, just that we won't need them if
+                                  we don't use the VLM device */
+                               confreg[2] = superio_inb(0x2B);
+                               confreg[3] = superio_inb(0x25);
+
+                               if (confreg[2] & 0x40) {
+                                       printk(KERN_INFO "pc87360.o: Using "
+                                              "thermistors for temperature "
+                                              "monitoring\n");
+                               }
+                               if (confreg[3] & 0xE0) {
+                                       printk(KERN_INFO "pc87360.o: VID "
+                                              "inputs routed (mode %u)\n",
+                                               confreg[3] >> 5);
+                               }
+                       }
+               }
+       }
+
+       superio_exit();
+       return 0;
+}
+
+/* We don't really care about the address.
+   Read from extra_isa instead. */
+int pc87360_detect(struct i2c_adapter *adapter, int address,
+                  unsigned short flags, int kind)
+{
+       int i;
+       struct i2c_client *new_client;
+       struct pc87360_data *data;
+       int err = 0;
+       const char *type_name = "pc87360";
+       const char *client_name = "PC8736x chip";
+       ctl_table *template = pc87360_dir_table_template;
+       int use_thermistors = 0;
+
+       if (!i2c_is_isa_adapter(adapter)) {
+               return 0;
+       }
+
+       for (i = 0; i < 3; i++) {
+               if (extra_isa[i]
+                && check_region(extra_isa[i], PC87360_EXTENT)) {
+                       printk(KERN_ERR "pc87360.o: Region 0x%x-0x%x already "
+                              "in use!\n", extra_isa[i],
+                              extra_isa[i]+PC87360_EXTENT-1);
+                       return -ENODEV;
+               }
+       }
+
+       if (!(data = kmalloc(sizeof(struct pc87360_data), GFP_KERNEL))) {
+               return -ENOMEM;
+       }
+       memset(data, 0x00, sizeof(struct pc87360_data));
+
+       new_client = &data->client;
+       new_client->addr = address;
+       init_MUTEX(&data->lock);
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &pc87360_driver;
+       new_client->flags = 0;
+
+       data->fannr = 2;
+       data->innr = 0;
+       data->tempnr = 0;
+       
+       switch (devid) {
+       case 0xe8:
+               type_name = "pc87363";
+               break;
+       case 0xe4:
+               type_name = "pc87364";
+               data->fannr = 3;
+               break;
+       case 0xe5:
+               type_name = "pc87365";
+               template = pc87365_dir_table_template;
+               data->fannr = extra_isa[0] ? 3 : 0;
+               data->innr = extra_isa[1] ? 11 : 0;
+               data->tempnr = extra_isa[2] ? 2 : 0;
+               break;
+       case 0xe9:
+               type_name = "pc87366";
+               template = pc87365_dir_table_template;
+               data->fannr = extra_isa[0] ? 3 : 0;
+               data->innr = extra_isa[1] ? 14 : 0;
+               data->tempnr = extra_isa[2] ? 3 : 0;
+               break;
+       }
+
+       /* Retrieve the fans configuration from Super-I/O space */
+       if (data->fannr)
+               data->fan_conf = confreg[0] | (confreg[1] << 8);
+
+       for (i = 0; i < 3; i++) {
+               if ((data->address[i] = extra_isa[i])) {
+                       request_region(extra_isa[i], PC87360_EXTENT, "pc87360");
+               }
+       }
+       strcpy(new_client->name, client_name);
+
+       new_client->id = pc87360_id++;
+       data->valid = 0;
+       init_MUTEX(&data->update_lock);
+
+       if ((err = i2c_attach_client(new_client)))
+               goto ERROR1;
+
+       /* Use the correct reference voltage
+          Unless both the VLM and the TMS logical devices agree to
+          use an external Vref, the internal one is used. */
+       if (data->innr) {
+               i = pc87360_read_value(data, LD_IN, NO_BANK,
+                                      PC87365_REG_IN_CONFIG);
+               if (data->tempnr) {
+                       i &= pc87360_read_value(data, LD_TEMP, NO_BANK,
+                                               PC87365_REG_TEMP_CONFIG);
+               }
+               data->in_vref = (i&0x02) ? 3025 : 2966;
+#ifdef DEBUG
+               printk(KERN_DEBUG "pc87360.o: Using %s reference voltage\n",
+                      (i&0x02) ? "external" : "internal");
+#endif
+
+               data->vid_conf = confreg[3];
+               data->vrm = 90;
+       }
+
+       /* Fan clock dividers may be needed before any data is read */
+       for (i = 0; i < data->fannr; i++) {
+               data->fan_status[i] = pc87360_read_value(data, LD_FAN,
+                                     NO_BANK, PC87360_REG_FAN_STATUS(i));
+       }
+
+       if (init > 0) {
+               if (devid == 0xe9 && data->address[1]) /* PC87366 */
+                       use_thermistors = confreg[2] & 0x40;
+
+               pc87360_init_client(new_client, use_thermistors);
+       }
+
+       if ((i = i2c_register_entry((struct i2c_client *) new_client,
+                                   type_name, template)) < 0) {
+               err = i;
+               goto ERROR2;
+       }
+       data->sysctl_id = i;
+
+       return 0;
+
+ERROR2:
+       i2c_detach_client(new_client);
+ERROR1:
+       for (i = 0; i < 3; i++) {
+               if (data->address[i]) {
+                       release_region(data->address[i], PC87360_EXTENT);
+               }
+       }
+       kfree(data);
+       return err;
+}
+
+static int pc87360_detach_client(struct i2c_client *client)
+{
+       struct pc87360_data *data = client->data;
+       int i, err;
+
+       i2c_deregister_entry(data->sysctl_id);
+
+       if ((err = i2c_detach_client(client))) {
+               printk(KERN_ERR "pc87360.o: Client deregistration failed, "
+                      "client not detached.\n");
+               return err;
+       }
+
+       for (i = 0; i < 3; i++) {
+               if (data->address[i]) {
+                       release_region(data->address[i], PC87360_EXTENT);
+               }
+       }
+       kfree(client->data);
+
+       return 0;
+}
+
+/* ldi is the logical device index
+   bank is for voltages and temperatures only */
+static int pc87360_read_value(struct pc87360_data *data, u8 ldi, u8 bank,
+                             u8 reg)
+{
+       int res;
+
+       down(&(data->lock));
+       if (bank != NO_BANK) {
+               outb_p(bank, data->address[ldi] + PC87365_REG_BANK);
+       }
+       res = inb_p(data->address[ldi] + reg);
+       up(&(data->lock));
+       return res;
+}
+
+static void pc87360_write_value(struct pc87360_data *data, u8 ldi, u8 bank,
+                               u8 reg, u8 value)
+{
+       down(&(data->lock));
+       if (bank != NO_BANK) {
+               outb_p(bank, data->address[ldi] + PC87365_REG_BANK);
+       }
+       outb_p(value, data->address[ldi] + reg);
+       up(&(data->lock));
+}
+
+static void pc87360_init_client(struct i2c_client *client, int use_thermistors)
+{
+       struct pc87360_data *data = client->data;
+       int i, nr;
+       const u8 init_in[14] = { 2, 2, 2, 2, 2, 2, 2, 1, 1, 3, 1, 2, 2, 2 };
+       const u8 init_temp[3] = { 2, 2, 1 };
+       u8 reg;
+
+       if (init >= 2 && data->innr) {
+               reg = pc87360_read_value(data, LD_IN, NO_BANK,
+                                        PC87365_REG_IN_CONVRATE);
+               printk(KERN_INFO "pc87360.o: VLM conversion set to"
+                      "1s period, 160us delay\n");
+               pc87360_write_value(data, LD_IN, NO_BANK,
+                                   PC87365_REG_IN_CONVRATE,
+                                   (reg & 0xC0) | 0x11);
+       }
+
+       nr = data->innr < 11 ? data->innr : 11;
+       for (i=0; i<nr; i++) {
+               if (init >= init_in[i]) {
+                       /* Forcibly enable voltage channel */
+                       reg = pc87360_read_value(data, LD_IN, i,
+                                                PC87365_REG_IN_STATUS);
+                       if (!(reg & 0x01)) {
+#ifdef DEBUG
+                               printk(KERN_DEBUG "pc87360.o: Forcibly "
+                                      "enabling in%d\n", i);
+#endif
+                               pc87360_write_value(data, LD_IN, i,
+                                                   PC87365_REG_IN_STATUS,
+                                                   (reg & 0x68) | 0x87);
+                       }
+               }
+       }
+
+       /* We can't blindly trust the Super-I/O space configuration bit,
+          most BIOS won't set it properly */
+       for (i=11; i<data->innr; i++) {
+               reg = pc87360_read_value(data, LD_IN, i,
+                                        PC87365_REG_TEMP_STATUS);
+               use_thermistors = use_thermistors || (reg & 0x01);
+       }
+
+       i = use_thermistors ? 2 : 0;
+       for (; i<data->tempnr; i++) {
+               if (init >= init_temp[i]) {
+                       /* Forcibly enable temperature channel */
+                       reg = pc87360_read_value(data, LD_TEMP, i,
+                                                PC87365_REG_TEMP_STATUS);
+                       if (!(reg & 0x01)) {
+#ifdef DEBUG
+                               printk(KERN_DEBUG "pc87360.o: Forcibly "
+                                      "enabling temp%d\n", i+1);
+#endif
+                               pc87360_write_value(data, LD_TEMP, i,
+                                                   PC87365_REG_TEMP_STATUS,
+                                                   0xCF);
+                       }
+               }
+       }
+
+       if (use_thermistors) {
+               for (i=11; i<data->innr; i++) {
+                       if (init >= init_in[i]) {
+                               /* The pin may already be used by thermal
+                                  diodes */
+                               reg = pc87360_read_value(data, LD_TEMP, (i-11)/2,
+                                                        PC87365_REG_TEMP_STATUS);
+                               if (reg & 0x01) {
+#ifdef DEBUG
+                                       printk(KERN_DEBUG "pc87360.o: Skipping "
+                                              "temp%d, pin already in use by ",
+                                              "temp%d\n", i-7, (i-11)/2);
+#endif
+                                       continue;
+                               }
+                       
+                               /* Forcibly enable thermistor channel */
+                               reg = pc87360_read_value(data, LD_IN, i,
+                                                        PC87365_REG_IN_STATUS);
+                               if (!(reg & 0x01)) {
+#ifdef DEBUG
+                                       printk(KERN_DEBUG "pc87360.o: Forcibly "
+                                              "enabling temp%d\n", i-7);
+#endif
+                                       pc87360_write_value(data, LD_IN, i,
+                                                           PC87365_REG_TEMP_STATUS,
+                                                           (reg & 0x60) | 0x8F);
+                               }
+                       }
+               }
+       }
+
+       if (data->innr) {
+               reg = pc87360_read_value(data, LD_IN, NO_BANK,
+                                        PC87365_REG_IN_CONFIG);
+               if (reg & 0x01) {
+#ifdef DEBUG
+                       printk(KERN_DEBUG "pc87360.o: Forcibly "
+                              "enabling monitoring (VLM)\n");
+#endif
+                       pc87360_write_value(data, LD_IN, NO_BANK,
+                                           PC87365_REG_IN_CONFIG,
+                                           reg & 0xFE);
+               }
+       }
+
+       if (data->tempnr) {
+               reg = pc87360_read_value(data, LD_TEMP, NO_BANK,
+                                        PC87365_REG_TEMP_CONFIG);
+               if (reg & 0x01) {
+#ifdef DEBUG
+                       printk(KERN_DEBUG "pc87360.o: Forcibly "
+                              "enabling monitoring (TMS)\n");
+#endif
+                       pc87360_write_value(data, LD_TEMP, NO_BANK,
+                                           PC87365_REG_TEMP_CONFIG,
+                                           reg & 0xFE);
+               }
+
+               if (init >= 2) {
+                       /* Chip config as documented by National Semi. */
+                       pc87360_write_value(data, LD_TEMP, 0xF, 0xA, 0x08);
+                       /* We voluntarily omit the bank here, in case the
+                          sequence itself matters. It shouldn't be a problem,
+                          since nobody else is supposed to access the
+                          device at that point. */
+                       pc87360_write_value(data, LD_TEMP, NO_BANK, 0xB, 0x04);
+                       pc87360_write_value(data, LD_TEMP, NO_BANK, 0xC, 0x35);
+                       pc87360_write_value(data, LD_TEMP, NO_BANK, 0xD, 0x05);
+                       pc87360_write_value(data, LD_TEMP, NO_BANK, 0xE, 0x05);
+               }
+       }
+}
+
+static void pc87360_autodiv(struct pc87360_data *data, int nr)
+{
+       u8 old_min = data->fan_min[nr];
+
+       /* Increase clock divider if needed and possible */
+       if ((data->fan_status[nr] & 0x04) /* overflow flag */
+        || (data->fan[nr] >= 224)) { /* next to overflow */
+               if ((data->fan_status[nr] & 0x60) != 0x60) {
+                       data->fan_status[nr] += 0x20;
+                       data->fan_min[nr] >>= 1;
+                       data->fan[nr] >>= 1;
+#ifdef DEBUG
+                       printk(KERN_DEBUG "pc87360.o: Increasing "
+                              "clock divider to %d for fan %d\n",
+                              FAN_DIV_FROM_REG(data->fan_status[nr]),
+                              nr+1);
+#endif
+               }
+       } else {
+               /* Decrease clock divider if possible */
+               while (!(data->fan_min[nr] & 0x80) /* fan min "nails" divider */
+                && data->fan[nr] < 85 /* bad accuracy */
+                && (data->fan_status[nr] & 0x60) != 0x00) {
+                       data->fan_status[nr] -= 0x20;
+                       data->fan_min[nr] <<= 1;
+                       data->fan[nr] <<= 1;
+#ifdef DEBUG
+                       printk(KERN_DEBUG "pc87360.o: Decreasing "
+                              "clock divider to %d for fan %d\n",
+                              FAN_DIV_FROM_REG(data->fan_status[nr]),
+                              nr+1);
+#endif
+               }
+       }
+
+       /* Write new fan min if it changed */
+       if (old_min != data->fan_min[nr]) {
+               pc87360_write_value(data, LD_FAN, NO_BANK,
+                                   PC87360_REG_FAN_MIN(nr),
+                                   data->fan_min[nr]);
+       }
+}
+
+static void pc87360_update_client(struct i2c_client *client)
+{
+       struct pc87360_data *data = client->data;
+       u8 i;
+
+       down(&data->update_lock);
+
+       if ((jiffies - data->last_updated > HZ * 2) ||
+           (jiffies < data->last_updated) || !data->valid) {
+#ifdef DEBUG
+               printk(KERN_DEBUG "pc87360.o: Data update\n");
+#endif
+
+               /* Fans */
+               for (i = 0; i < data->fannr; i++) {
+                       if (FAN_CONFIG_MONITOR(data->fan_conf, i)) {
+                               data->fan_status[i] = pc87360_read_value(data,
+                                                     LD_FAN, NO_BANK,
+                                                     PC87360_REG_FAN_STATUS(i));
+                               data->fan[i] = pc87360_read_value(data, LD_FAN,
+                                              NO_BANK, PC87360_REG_FAN(i));
+                               data->fan_min[i] = pc87360_read_value(data,
+                                                  LD_FAN, NO_BANK,
+                                                  PC87360_REG_FAN_MIN(i));
+                               /* Change clock divider if needed */
+                               pc87360_autodiv(data, i);
+                               /* Clear bits and write new divider */
+                               pc87360_write_value(data, LD_FAN, NO_BANK,
+                                                   PC87360_REG_FAN_STATUS(i),
+                                                   data->fan_status[i]);
+                       }
+                       data->pwm[i] = pc87360_read_value(data, LD_FAN,
+                                      NO_BANK, PC87360_REG_PWM(i));
+               }
+
+               /* Voltages */
+               for (i = 0; i < data->innr; i++) {
+                       data->in_status[i] = pc87360_read_value(data, LD_IN, i,
+                                            PC87365_REG_IN_STATUS);
+                       /* Clear bits */
+                       pc87360_write_value(data, LD_IN, i,
+                                           PC87365_REG_IN_STATUS,
+                                           data->in_status[i]);
+                       if ((data->in_status[i] & 0x81) == 0x81) {
+                               data->in[i] = pc87360_read_value(data, LD_IN,
+                                             i, PC87365_REG_IN);
+                       }
+                       if (data->in_status[i] & 0x01) {
+                               data->in_min[i] = pc87360_read_value(data,
+                                                 LD_IN, i,
+                                                 PC87365_REG_IN_MIN);
+                               data->in_max[i] = pc87360_read_value(data,
+                                                 LD_IN, i,
+                                                 PC87365_REG_IN_MAX);
+                               if (i >= 11)
+                                       data->in_crit[i-11] =
+                                               pc87360_read_value(data, LD_IN,
+                                               i, PC87365_REG_TEMP_CRIT);
+                       }
+               }
+               if (data->innr) {
+                       data->in_alarms = pc87360_read_value(data, LD_IN,
+                                         NO_BANK, PC87365_REG_IN_ALARMS1)
+                                       | ((pc87360_read_value(data, LD_IN,
+                                           NO_BANK, PC87365_REG_IN_ALARMS2)
+                                           & 0x07) << 8);
+                       data->vid = (data->vid_conf & 0xE0) ?
+                                   pc87360_read_value(data, LD_IN,
+                                   NO_BANK, PC87365_REG_VID) : 0x1F;
+               }
+
+               /* Temperatures */
+               for (i = 0; i < data->tempnr; i++) {
+                       data->temp_status[i] = pc87360_read_value(data,
+                                              LD_TEMP, i,
+                                              PC87365_REG_TEMP_STATUS);
+                       /* Clear bits */
+                       pc87360_write_value(data, LD_TEMP, i,
+                                           PC87365_REG_TEMP_STATUS,
+                                           data->temp_status[i]);
+                       if ((data->temp_status[i] & 0x81) == 0x81) {
+                               data->temp[i] = pc87360_read_value(data,
+                                               LD_TEMP, i,
+                                               PC87365_REG_TEMP);
+                       }
+                       if (data->temp_status[i] & 0x01) {
+                               data->temp_min[i] = pc87360_read_value(data,
+                                                   LD_TEMP, i,
+                                                   PC87365_REG_TEMP_MIN);
+                               data->temp_max[i] = pc87360_read_value(data,
+                                                   LD_TEMP, i,
+                                                   PC87365_REG_TEMP_MAX);
+                               data->temp_crit[i] = pc87360_read_value(data,
+                                                    LD_TEMP, i,
+                                                    PC87365_REG_TEMP_CRIT);
+                       }
+               }
+               if (data->tempnr) {
+                       data->temp_alarms = pc87360_read_value(data, LD_TEMP,
+                                           NO_BANK, PC87365_REG_TEMP_ALARMS)
+                                         & 0x3F;
+               }
+
+               data->last_updated = jiffies;
+               data->valid = 1;
+       }
+
+       up(&data->update_lock);
+}
+
+
+void pc87365_alarms(struct i2c_client *client, int operation, int ctl_name,
+                   int *nrels_mag, long *results)
+{
+       struct pc87360_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               pc87360_update_client(client);
+               results[0] = data->in_alarms;
+               results[1] = data->temp_alarms;
+               *nrels_mag = 2;
+       }
+}
+
+void pc87360_fan(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct pc87360_data *data = client->data;
+       int nr = ctl_name - PC87360_SYSCTL_FAN1;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               pc87360_update_client(client);
+               results[0] = FAN_FROM_REG(data->fan_min[nr],
+                            FAN_DIV_FROM_REG(data->fan_status[nr]));
+               results[1] = FAN_FROM_REG(data->fan[nr],
+                            FAN_DIV_FROM_REG(data->fan_status[nr]));
+               *nrels_mag = 2;
+       }
+       /* We ignore National's recommendation */
+       else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (nr >= data->fannr)
+                       return;
+               if (*nrels_mag >= 1) {
+                       int fan_min = FAN_TO_REG(results[0],
+                                     FAN_DIV_FROM_REG(data->fan_status[nr]));
+                       /* If it wouldn't fit, change clock divisor */
+                       while (fan_min > 255
+                           && (data->fan_status[nr] & 0x60) != 0x60) {
+                               fan_min >>= 1;
+                               data->fan[nr] >>= 1;
+                               data->fan_status[nr] += 0x20;
+                       }
+                       data->fan_min[nr] = fan_min > 255 ? 255 : fan_min;
+                       pc87360_write_value(data, LD_FAN, NO_BANK,
+                                           PC87360_REG_FAN_MIN(nr),
+                                           data->fan_min[nr]);
+                       /* Write new divider, preserve alarm bits */
+                       pc87360_write_value(data, LD_FAN, NO_BANK,
+                                           PC87360_REG_FAN_STATUS(nr),
+                                           data->fan_status[nr] & 0xF9);
+               }
+       }
+}
+
+void pc87360_fan_div(struct i2c_client *client, int operation,
+                    int ctl_name, int *nrels_mag, long *results)
+{
+       struct pc87360_data *data = client->data;
+       int i;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               pc87360_update_client(client);
+               for (i = 0; i < data->fannr; i++) {
+                       results[i] = FAN_DIV_FROM_REG(data->fan_status[i]);
+               }
+               for (; i < 3; i++) {
+                       results[i] = 0;
+               }
+               *nrels_mag = 3;
+       }
+}
+
+void pc87360_pwm(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct pc87360_data *data = client->data;
+       int nr = ctl_name - PC87360_SYSCTL_PWM1;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               pc87360_update_client(client);
+               results[0] = PWM_FROM_REG(data->pwm[nr],
+                            FAN_CONFIG_INVERT(data->fan_conf, nr));
+               results[1] = FAN_CONFIG_CONTROL(data->fan_conf, nr);
+               *nrels_mag = 2;
+       }
+       else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (nr >= data->fannr)
+                       return;
+               if (*nrels_mag >= 1) {
+                       data->pwm[nr] = PWM_TO_REG(results[0],
+                                       FAN_CONFIG_INVERT(data->fan_conf, nr));
+                       pc87360_write_value(data, LD_FAN, NO_BANK,
+                                           PC87360_REG_PWM(nr),
+                                           data->pwm[nr]);
+               }
+       }
+}
+
+void pc87360_fan_status(struct i2c_client *client, int operation, int ctl_name,
+                       int *nrels_mag, long *results)
+{
+       struct pc87360_data *data = client->data;
+       int nr = ctl_name - PC87360_SYSCTL_FAN1_STATUS;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               pc87360_update_client(client);
+               results[0] = FAN_STATUS_FROM_REG(data->fan_status[nr]);
+               *nrels_mag = 1;
+       }
+}
+
+void pc87365_in(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       struct pc87360_data *data = client->data;
+       int nr = ctl_name - PC87365_SYSCTL_IN0;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 3;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               pc87360_update_client(client);
+               results[0] = IN_FROM_REG(data->in_min[nr], data->in_vref);
+               results[1] = IN_FROM_REG(data->in_max[nr], data->in_vref);
+               if (nr < 11) {
+                       *nrels_mag = 3;
+               } else {
+                       results[2] = IN_FROM_REG(data->in_crit[nr-11],
+                                                data->in_vref);
+                       *nrels_mag = 4;
+               }
+               results[(*nrels_mag)-1] = IN_FROM_REG(data->in[nr],
+                                                     data->in_vref);
+       }
+       else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->in_min[nr] = IN_TO_REG(results[0],
+                                                    data->in_vref);
+                       pc87360_write_value(data, LD_IN, nr,
+                                           PC87365_REG_IN_MIN,
+                                           data->in_min[nr]);
+               }
+               if (*nrels_mag >= 2) {
+                       data->in_max[nr] = IN_TO_REG(results[1],
+                                                    data->in_vref);
+                       pc87360_write_value(data, LD_IN, nr,
+                                           PC87365_REG_IN_MAX,
+                                           data->in_max[nr]);
+               }
+               if (*nrels_mag >= 3 && nr >= 11) {
+                       data->in_crit[nr-11] = IN_TO_REG(results[2],
+                                                        data->in_vref);
+                       pc87360_write_value(data, LD_IN, nr,
+                                           PC87365_REG_TEMP_CRIT,
+                                           data->in_crit[nr-11]);
+               }
+       }
+}
+
+void pc87365_in_status(struct i2c_client *client, int operation, int ctl_name,
+                      int *nrels_mag, long *results)
+{
+       struct pc87360_data *data = client->data;
+       int nr = ctl_name - PC87365_SYSCTL_IN0_STATUS;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               pc87360_update_client(client);
+               results[0] = data->in_status[nr];
+               *nrels_mag = 1;
+       }
+}
+
+void pc87365_vid(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct pc87360_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 3;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               pc87360_update_client(client);
+               results[0] = vid_from_reg(data->vid & 0x1f, data->vrm);
+               *nrels_mag = 1;
+       }
+}
+
+void pc87365_vrm(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct pc87360_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               results[0] = data->vrm;
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1)
+                       data->vrm = results[0];
+       }
+}
+
+void pc87365_temp(struct i2c_client *client, int operation, int ctl_name,
+                 int *nrels_mag, long *results)
+{
+       struct pc87360_data *data = client->data;
+       int nr = ctl_name - PC87365_SYSCTL_TEMP1;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               pc87360_update_client(client);
+               results[0] = TEMP_FROM_REG(data->temp_max[nr]);
+               results[1] = TEMP_FROM_REG(data->temp_min[nr]);
+               results[2] = TEMP_FROM_REG(data->temp_crit[nr]);
+               results[3] = TEMP_FROM_REG(data->temp[nr]);
+               *nrels_mag = 4;
+       }
+       else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (nr >= data->tempnr)
+                       return;
+               if (*nrels_mag >= 1) {
+                       data->temp_max[nr] = TEMP_TO_REG(results[0]);
+                       pc87360_write_value(data, LD_TEMP, nr,
+                                           PC87365_REG_TEMP_MAX,
+                                           data->temp_max[nr]);
+               }
+               if (*nrels_mag >= 2) {
+                       data->temp_min[nr] = TEMP_TO_REG(results[1]);
+                       pc87360_write_value(data, LD_TEMP, nr,
+                                           PC87365_REG_TEMP_MIN,
+                                           data->temp_min[nr]);
+               }
+               if (*nrels_mag >= 3) {
+                       data->temp_crit[nr] = TEMP_TO_REG(results[2]);
+                       pc87360_write_value(data, LD_TEMP, nr,
+                                           PC87365_REG_TEMP_CRIT,
+                                           data->temp_crit[nr]);
+               }
+       }
+}
+
+void pc87365_temp_status(struct i2c_client *client, int operation, int ctl_name,
+                        int *nrels_mag, long *results)
+{
+       struct pc87360_data *data = client->data;
+       int nr = ctl_name - PC87365_SYSCTL_TEMP1_STATUS;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               pc87360_update_client(client);
+               results[0] = data->temp_status[nr];
+               *nrels_mag = 1;
+       }
+}
+
+
+static int __init pc87360_init(void)
+{
+       int i;
+
+       printk(KERN_INFO "pc87360.o version %s (%s)\n", LM_VERSION, LM_DATE);
+
+       if (pc87360_find(&devid, extra_isa)) {
+               printk(KERN_WARNING "pc87360.o: PC8736x not detected, "
+                      "module not inserted.\n");
+               return -ENODEV;
+       }
+
+       /* Arbitrarily pick one of the addresses */
+       for (i = 0; i < 3; i++) {
+               if (extra_isa[i] != 0x0000) {
+                       normal_isa[0] = extra_isa[i];
+                       break;
+               }
+       }
+
+       if (normal_isa[0] == 0x0000) {
+               printk(KERN_WARNING "pc87360.o: No active logical device, "
+                      "module not inserted.\n");
+               return -ENODEV;
+       
+       }
+
+       return i2c_add_driver(&pc87360_driver);
+}
+
+static void __exit pc87360_exit(void)
+{
+       i2c_del_driver(&pc87360_driver);
+}
+
+
+MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
+MODULE_DESCRIPTION("PC8736x hardware monitor");
+MODULE_LICENSE("GPL");
+
+module_init(pc87360_init);
+module_exit(pc87360_exit);
--- linux-old/drivers/sensors/pcf8574.c Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/pcf8574.c     Mon Dec 13 20:18:51 2004
@@ -0,0 +1,309 @@
+/*
+    pcf8574.c - Part of lm_sensors, Linux kernel modules for hardware
+             monitoring
+    Copyright (c) 2000  Frodo Looijaard <frodol@dds.nl>, 
+                        Philip Edelbrock <phil@netroedge.com>,
+                        Dan Eaton <dan.eaton@rocketlogix.com>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+    
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/* A few notes about the PCF8574:
+
+* The PCF8574 is an 8-bit I/O expander for the I2C bus produced by
+  Philips Semiconductors.  It is designed to provide a byte I2C
+  interface to up to 8 separate devices.
+  
+* The PCF8574 appears as a very simple SMBus device which can be
+  read from or written to with SMBUS byte read/write accesses.
+
+* Because of the general purpose nature of this device, it will most
+  likely be necessary to customize the /proc interface to suit the
+  specific application.
+
+  --Dan
+
+*/
+
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+MODULE_LICENSE("GPL");
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = { SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { 0x20, 0x27, 0x38, 0x3f, SENSORS_I2C_END };
+static unsigned int normal_isa[] = { SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+/* Insmod parameters */
+SENSORS_INSMOD_2(pcf8574, pcf8574a);
+
+/* The PCF8574 registers */
+
+/* (No registers.  [Wow! This thing is SIMPLE!] ) */
+
+/* Initial values */
+#define PCF8574_INIT 255       /* All outputs on (input mode) */
+
+/* Each client has this additional data */
+struct pcf8574_data {
+       struct i2c_client client;
+       int sysctl_id;
+
+       struct semaphore update_lock;
+
+       u8 read, write;         /* Register values */
+};
+
+static int pcf8574_attach_adapter(struct i2c_adapter *adapter);
+static int pcf8574_detect(struct i2c_adapter *adapter, int address,
+                         unsigned short flags, int kind);
+static int pcf8574_detach_client(struct i2c_client *client);
+
+static void pcf8574_read(struct i2c_client *client, int operation,
+                                      int ctl_name, int *nrels_mag, long *results);
+static void pcf8574_write(struct i2c_client *client, int operation,
+                                      int ctl_name, int *nrels_mag, long *results);
+static void pcf8574_update_client(struct i2c_client *client);
+static void pcf8574_init_client(struct i2c_client *client);
+
+/* This is the driver that will be inserted */
+static struct i2c_driver pcf8574_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "PCF8574 sensor chip driver",
+       .id             = I2C_DRIVERID_PCF8574,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = pcf8574_attach_adapter,
+       .detach_client  = pcf8574_detach_client,
+};
+
+
+/* -- SENSORS SYSCTL START -- */
+#define PCF8574_SYSCTL_READ     1000
+#define PCF8574_SYSCTL_WRITE    1001
+
+/* -- SENSORS SYSCTL END -- */
+
+/* These files are created for each detected PCF8574. This is just a template;
+   though at first sight, you might think we could use a statically
+   allocated list, we need some way to get back to the parent - which
+   is done through one of the 'extra' fields which are initialized
+   when a new copy is allocated. */
+static ctl_table pcf8574_dir_table_template[] = {
+       {PCF8574_SYSCTL_READ, "read", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &pcf8574_read},
+       {PCF8574_SYSCTL_WRITE, "write", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &pcf8574_write},
+       {0}
+};
+
+static int pcf8574_id = 0;
+
+static int pcf8574_attach_adapter(struct i2c_adapter *adapter)
+{
+       return i2c_detect(adapter, &addr_data, pcf8574_detect);
+}
+
+/* This function is called by i2c_detect */
+int pcf8574_detect(struct i2c_adapter *adapter, int address,
+                  unsigned short flags, int kind)
+{
+       int i;
+       struct i2c_client *new_client;
+       struct pcf8574_data *data;
+       int err = 0;
+       const char *type_name, *client_name;
+
+       /* Make sure we aren't probing the ISA bus!! This is just a safety check
+          at this moment; i2c_detect really won't call us. */
+#ifdef DEBUG
+       if (i2c_is_isa_adapter(adapter)) {
+               printk
+                   ("pcf8574.o: pcf8574_detect called for an ISA bus adapter?!?\n");
+               return 0;
+       }
+#endif
+
+       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
+               goto ERROR0;
+
+       /* OK. For now, we presume we have a valid client. We now create the
+          client structure, even though we cannot fill it completely yet. */
+       if (!(data = kmalloc(sizeof(struct pcf8574_data), GFP_KERNEL))) {
+               err = -ENOMEM;
+               goto ERROR0;
+       }
+
+       new_client = &data->client;
+       new_client->addr = address;
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &pcf8574_driver;
+       new_client->flags = 0;
+
+       /* Now, we would do the remaining detection. But the PCF8574 is plainly
+          impossible to detect! Stupid chip. */
+
+       /* Determine the chip type */
+       if (kind <= 0) {
+               if (address >= 0x38 && address <= 0x3f)
+                       kind = pcf8574a;
+               else
+                       kind = pcf8574;
+       }
+
+       if (kind == pcf8574a) {
+               type_name = "pcf8574a";
+               client_name = "PCF8574A chip";
+       } else {
+               type_name = "pcf8574a";
+               client_name = "PCF8574A chip";
+       }
+
+       /* Fill in the remaining client fields and put it into the global list */
+       strcpy(new_client->name, client_name);
+
+       new_client->id = pcf8574_id++;
+       init_MUTEX(&data->update_lock);
+
+       /* Tell the I2C layer a new client has arrived */
+       if ((err = i2c_attach_client(new_client)))
+               goto ERROR1;
+
+       /* Register a new directory entry with module sensors */
+       if ((i = i2c_register_entry(new_client, type_name,
+                                   pcf8574_dir_table_template)) < 0) {
+               err = i;
+               goto ERROR2;
+       }
+       data->sysctl_id = i;
+
+       /* Initialize the PCF8574 chip */
+       pcf8574_init_client(new_client);
+       return 0;
+
+/* OK, this is not exactly good programming practice, usually. But it is
+   very code-efficient in this case. */
+
+      ERROR2:
+       i2c_detach_client(new_client);
+      ERROR1:
+       kfree(data);
+      ERROR0:
+       return err;
+}
+
+static int pcf8574_detach_client(struct i2c_client *client)
+{
+       int err;
+
+       i2c_deregister_entry(((struct pcf8574_data *) (client->data))->
+                                sysctl_id);
+
+       if ((err = i2c_detach_client(client))) {
+               printk("pcf8574.o: Client deregistration failed, "
+                      "client not detached.\n");
+               return err;
+       }
+
+       kfree(client->data);
+
+       return 0;
+}
+
+/* Called when we have found a new PCF8574. */
+static void pcf8574_init_client(struct i2c_client *client)
+{
+       struct pcf8574_data *data = client->data;
+       data->write = PCF8574_INIT;
+       i2c_smbus_write_byte(client, data->write);
+}
+
+
+static void pcf8574_update_client(struct i2c_client *client)
+{
+       struct pcf8574_data *data = client->data;
+
+       down(&data->update_lock);
+
+#ifdef DEBUG
+       printk("Starting pcf8574 update\n");
+#endif
+
+       data->read = i2c_smbus_read_byte(client); 
+
+       up(&data->update_lock);
+}
+
+
+void pcf8574_read(struct i2c_client *client, int operation,
+                 int ctl_name, int *nrels_mag, long *results)
+{
+       struct pcf8574_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               pcf8574_update_client(client);
+               results[0] = data->read;
+               *nrels_mag = 1;
+       }  
+}
+void pcf8574_write(struct i2c_client *client, int operation,
+                  int ctl_name, int *nrels_mag, long *results)
+{
+       struct pcf8574_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               results[0] = data->write; 
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->write = results[0];
+                       i2c_smbus_write_byte(client, data->write);
+               }
+       }
+}
+
+
+static int __init sm_pcf8574_init(void)
+{
+       printk("pcf8574.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       return i2c_add_driver(&pcf8574_driver);
+}
+
+static void __exit sm_pcf8574_exit(void)
+{
+       i2c_del_driver(&pcf8574_driver);
+}
+
+
+MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>, "
+             "Philip Edelbrock <phil@netroedge.com>, "
+             "Dan Eaton <dan.eaton@rocketlogix.com> and "
+             "Aurelien Jarno <aurelien@aurel32.net>");
+MODULE_DESCRIPTION("PCF8574 driver");
+
+module_init(sm_pcf8574_init);
+module_exit(sm_pcf8574_exit);
--- linux-old/drivers/sensors/pcf8591.c Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/pcf8591.c     Mon Dec 13 20:18:51 2004
@@ -0,0 +1,448 @@
+/*
+    pcf8591.c - Part of lm_sensors, Linux kernel modules for hardware
+             monitoring
+    Copyright (c) 2001  Aurelien Jarno <aurelien@aurel32.net>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = { SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { 0x48, 0x4f, SENSORS_I2C_END };
+static unsigned int normal_isa[] = { SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+/* Insmod parameters */
+SENSORS_INSMOD_1(pcf8591);
+
+/* The PCF8591 control byte */
+/*    7    6    5    4    3    2    1    0   */
+/* |  0 |AOEF|   AIP   |  0 |AINC|  AICH   | */
+
+#define PCF8591_CONTROL_BYTE_AOEF 0x40  /* Analog Output Enable Flag */
+                                        /* (analog output active if 1) */
+
+#define PCF8591_CONTROL_BYTE_AIP 0x30   /* Analog Input Programming */
+                                        /* 0x00 = four single ended inputs */
+                                        /* 0x10 = three differential inputs */
+                                        /* 0x20 = single ended and differential mixed */
+                                        /* 0x30 = two differential inputs */
+
+#define PCF8591_CONTROL_BYTE_AINC 0x04  /* Autoincrement Flag */
+                                        /* (switch on if 1) */
+
+#define PCF8591_CONTROL_BYTE_AICH 0x03  /* Analog Output Enable Flag */
+                                        /* 0x00 = channel 0 */
+                                        /* 0x01 = channel 1 */
+                                        /* 0x02 = channel 2 */
+                                        /* 0x03 = channel 3 */
+
+
+/* Initial values */
+#define PCF8591_INIT_CONTROL_BYTE (PCF8591_CONTROL_BYTE_AOEF | PCF8591_CONTROL_BYTE_AINC)
+                /* DAC out enabled, four single ended inputs, autoincrement */
+
+#define PCF8591_INIT_AOUT 0             /* DAC out = 0 */
+
+
+/* Conversions. */
+#define REG_TO_SIGNED(reg) (reg & 0x80)?(reg - 256):(reg)
+                          /* Convert signed 8 bit value to signed value */
+
+
+struct pcf8591_data {
+       struct i2c_client client;
+        int sysctl_id;
+
+        struct semaphore update_lock;
+        char valid;             /* !=0 if following fields are valid */
+        unsigned long last_updated;     /* In jiffies */
+
+        u8 control_byte;
+        u8 ch[4];
+        u8 aout;
+};
+
+static int pcf8591_attach_adapter(struct i2c_adapter *adapter);
+static int pcf8591_detect(struct i2c_adapter *adapter, int address,
+                          unsigned short flags, int kind);
+static int pcf8591_detach_client(struct i2c_client *client);
+
+static void pcf8591_update_client(struct i2c_client *client);
+static void pcf8591_init_client(struct i2c_client *client);
+
+static void pcf8591_ain_conf(struct i2c_client *client, int operation,
+                             int ctl_name, int *nrels_mag, long *results);
+static void pcf8591_ain(struct i2c_client *client, int operation,
+                        int ctl_name, int *nrels_mag, long *results);
+static void pcf8591_aout_enable(struct i2c_client *client, int operation,
+                                int ctl_name, int *nrels_mag, long *results);
+static void pcf8591_aout(struct i2c_client *client, int operation,
+                         int ctl_name, int *nrels_mag, long *results);
+
+
+/* This is the driver that will be inserted */
+static struct i2c_driver pcf8591_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "PCF8591 sensor chip driver",
+       .id             = I2C_DRIVERID_PCF8591,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = pcf8591_attach_adapter,
+       .detach_client  = pcf8591_detach_client,
+};
+
+static int pcf8591_id = 0;
+
+/* The /proc/sys entries */
+
+/* -- SENSORS SYSCTL START -- */
+#define PCF8591_SYSCTL_AIN_CONF 1000      /* Analog input configuration */
+#define PCF8591_SYSCTL_CH0 1001           /* Input channel 1 */
+#define PCF8591_SYSCTL_CH1 1002           /* Input channel 2 */
+#define PCF8591_SYSCTL_CH2 1003           /* Input channel 3 */
+#define PCF8591_SYSCTL_CH3 1004           /* Input channel 4 */
+#define PCF8591_SYSCTL_AOUT_ENABLE 1005   /* Analog output enable flag */
+#define PCF8591_SYSCTL_AOUT 1006          /* Analog output */
+/* -- SENSORS SYSCTL END -- */
+
+/* These files are created for each detected PCF8591. This is just a template;
+   though at first sight, you might think we could use a statically
+   allocated list, we need some way to get back to the parent - which
+   is done through one of the 'extra' fields which are initialized
+   when a new copy is allocated. */
+static ctl_table pcf8591_dir_table_template[] = {
+        {PCF8591_SYSCTL_AIN_CONF, "ain_conf", NULL, 0, 0644, NULL, &i2c_proc_real,
+         &i2c_sysctl_real, NULL, &pcf8591_ain_conf},
+        {PCF8591_SYSCTL_CH0, "ch0", NULL, 0, 0444, NULL, &i2c_proc_real,
+         &i2c_sysctl_real, NULL, &pcf8591_ain},
+        {PCF8591_SYSCTL_CH1, "ch1", NULL, 0, 0444, NULL, &i2c_proc_real,
+         &i2c_sysctl_real, NULL, &pcf8591_ain},
+        {PCF8591_SYSCTL_CH2, "ch2", NULL, 0, 0444, NULL, &i2c_proc_real,
+         &i2c_sysctl_real, NULL, &pcf8591_ain},
+        {PCF8591_SYSCTL_CH3, "ch3", NULL, 0, 0444, NULL, &i2c_proc_real,
+         &i2c_sysctl_real, NULL, &pcf8591_ain},
+        {PCF8591_SYSCTL_AOUT_ENABLE, "aout_enable", NULL, 0, 0644, NULL, &i2c_proc_real,
+         &i2c_sysctl_real, NULL, &pcf8591_aout_enable},
+        {PCF8591_SYSCTL_AOUT, "aout", NULL, 0, 0644, NULL, &i2c_proc_real,
+         &i2c_sysctl_real, NULL, &pcf8591_aout},
+        {0}
+};
+
+
+/* This function is called when:
+     * pcf8591_driver is inserted (when this module is loaded), for each
+       available adapter
+     * when a new adapter is inserted (and pcf8591_driver is still present) */
+static int pcf8591_attach_adapter(struct i2c_adapter *adapter)
+{
+        return i2c_detect(adapter, &addr_data, pcf8591_detect);
+}
+
+/* This function is called by i2c_detect */
+int pcf8591_detect(struct i2c_adapter *adapter, int address,
+                unsigned short flags, int kind)
+{
+        int i;
+        struct i2c_client *new_client;
+        struct pcf8591_data *data;
+        int err = 0;
+
+        const char *type_name = "";
+        const char *client_name = "";
+
+        /* Make sure we aren't probing the ISA bus!! This is just a safety check at this moment; i2c_detect really won't call us. */
+#ifdef DEBUG
+        if (i2c_is_isa_adapter(adapter)) {
+                printk
+                    (KERN_ERR "pcf8591.o: pcf8591_detect called for an ISA bus adapter?!?\n");
+                return 0;
+        }
+#endif
+
+        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE
+                                     | I2C_FUNC_SMBUS_WRITE_BYTE_DATA))
+                goto ERROR0;
+
+        /* OK. For now, we presume we have a valid client. We now create the
+           client structure, even though we cannot fill it completely yet. */
+       if (!(data = kmalloc(sizeof(struct pcf8591_data), GFP_KERNEL))) {
+                err = -ENOMEM;
+                goto ERROR0;
+        }
+
+       new_client = &data->client;
+        new_client->addr = address;
+        new_client->data = data;
+        new_client->adapter = adapter;
+        new_client->driver = &pcf8591_driver;
+        new_client->flags = 0;
+
+        /* Now, we would do the remaining detection. But the PCF8591 is plainly
+           impossible to detect! Stupid chip. */
+
+        /* Determine the chip type - only one kind supported! */
+        if (kind <= 0)
+                kind = pcf8591;
+
+       type_name = "pcf8591";
+       client_name = "PCF8591 chip";
+
+        /* Fill in the remaining client fields and put it into the global list */
+        strcpy(new_client->name, client_name);
+
+        new_client->id = pcf8591_id++;
+        data->valid = 0;
+        init_MUTEX(&data->update_lock);
+
+        /* Tell the I2C layer a new client has arrived */
+        if ((err = i2c_attach_client(new_client)))
+                goto ERROR3;
+
+        /* Register a new directory entry with module sensors */
+        if ((i = i2c_register_entry(new_client,
+                                        type_name,
+                                        pcf8591_dir_table_template)) < 0) {
+                err = i;
+                goto ERROR4;
+        }
+        data->sysctl_id = i;
+
+        /* Initialize the PCF8591 chip */
+        pcf8591_init_client(new_client);
+        return 0;
+
+/* OK, this is not exactly good programming practice, usually. But it is
+   very code-efficient in this case. */
+
+      ERROR4:
+        i2c_detach_client(new_client);
+      ERROR3:
+       kfree(data);
+      ERROR0:
+        return err;
+}
+
+static int pcf8591_detach_client(struct i2c_client *client)
+{
+        int err;
+
+        i2c_deregister_entry(((struct pcf8591_data *) (client->data))->
+                                 sysctl_id);
+
+        if ((err = i2c_detach_client(client))) {
+                printk
+                    (KERN_ERR "pcf8591.o: Client deregistration failed, client not detached.\n");
+                return err;
+        }
+
+       kfree(client->data);
+
+        return 0;
+}
+
+/* Called when we have found a new PCF8591. */
+static void pcf8591_init_client(struct i2c_client *client)
+{
+        struct pcf8591_data *data = client->data;
+        data->control_byte = PCF8591_INIT_CONTROL_BYTE;
+        data->aout = PCF8591_INIT_AOUT;
+
+        i2c_smbus_write_byte_data(client, data->control_byte, data->aout);
+}
+
+static void pcf8591_update_client(struct i2c_client *client)
+{
+        struct pcf8591_data *data = client->data;
+
+        down(&data->update_lock);
+
+        if ((jiffies - data->last_updated > HZ + HZ / 2) ||
+            (jiffies < data->last_updated) || !data->valid) {
+
+#ifdef DEBUG
+                printk(KERN_DEBUG "Starting pcf8591 update\n");
+#endif
+
+                i2c_smbus_write_byte(client, data->control_byte);
+                i2c_smbus_read_byte(client);    /* The first byte transmitted contains the */
+                                                /* conversion code of the previous read cycled */
+                                                /* FLUSH IT ! */
+
+
+                /* Number of byte to read to signed depend on the analog input mode */
+                data->ch[0] = i2c_smbus_read_byte(client);
+                data->ch[1] = i2c_smbus_read_byte(client);
+                        /* In all case, read at least two values */
+
+                if ((data->control_byte & PCF8591_CONTROL_BYTE_AIP) != 0x30)
+                        data->ch[2] = i2c_smbus_read_byte(client);
+                        /* Read the third value if not in "two differential inputs" mode */
+
+                if ((data->control_byte & PCF8591_CONTROL_BYTE_AIP) == 0x00)
+                        data->ch[3] = i2c_smbus_read_byte(client);
+                        /* Read the fourth value only in "four single ended inputs" mode */
+
+                data->last_updated = jiffies;
+                data->valid = 1;
+        }
+
+        up(&data->update_lock);
+}
+
+/* The next few functions are the call-back functions of the /proc/sys and
+   sysctl files. Which function is used is defined in the ctl_table in
+   the extra1 field. */
+void pcf8591_ain_conf(struct i2c_client *client, int operation, int ctl_name,
+             int *nrels_mag, long *results)
+{
+        struct pcf8591_data *data = client->data;
+
+        if (operation == SENSORS_PROC_REAL_INFO)
+                *nrels_mag = 0;
+        else if (operation == SENSORS_PROC_REAL_READ) {
+                results[0] = (data->control_byte & PCF8591_CONTROL_BYTE_AIP) >> 4;
+                *nrels_mag = 1;
+        } else if (operation == SENSORS_PROC_REAL_WRITE) {
+                if (*nrels_mag >= 1) {
+                        if (results[0] >= 0 && results[0] <= 3)
+                        {
+                                data->control_byte &= ~PCF8591_CONTROL_BYTE_AIP;
+                                data->control_byte |= (results[0] << 4);
+                                i2c_smbus_write_byte(client, data->control_byte);
+                                data->valid = 0;
+                        }
+                }
+        }
+}
+
+void pcf8591_ain(struct i2c_client *client, int operation, int ctl_name,
+             int *nrels_mag, long *results)
+{
+        struct pcf8591_data *data = client->data;
+        int nr = ctl_name - PCF8591_SYSCTL_CH0;
+
+        if (operation == SENSORS_PROC_REAL_INFO)
+                *nrels_mag = 0;
+        else if (operation == SENSORS_PROC_REAL_READ) {
+                pcf8591_update_client(client);
+
+                /* Number of data to show and conversion to signed depend on */
+                /* the analog input mode */
+
+                switch(nr) {
+                        case 0:
+                                if (((data->control_byte & PCF8591_CONTROL_BYTE_AIP) == 0)
+                                   | ((data->control_byte & PCF8591_CONTROL_BYTE_AIP) == 2))
+                                        results[0] = data->ch[0];               /* single ended */
+                                else
+                                        results[0] = REG_TO_SIGNED(data->ch[0]);/* differential */
+                                break;
+                        case 1:
+                                if (((data->control_byte & PCF8591_CONTROL_BYTE_AIP) == 0)
+                                   | ((data->control_byte & PCF8591_CONTROL_BYTE_AIP) == 2))
+                                        results[0] = data->ch[1]; /* single ended */
+                                else
+                                        results[0] = REG_TO_SIGNED(data->ch[1]);/* differential */
+                                break;
+                        case 2:
+                                if ((data->control_byte & PCF8591_CONTROL_BYTE_AIP) == 3)
+                                        results[0] = 0;  /* channel not used */
+                                else if ((data->control_byte & PCF8591_CONTROL_BYTE_AIP) == 0)
+                                        results[0] = data->ch[2]; /* single ended */
+                                else
+                                        results[0] = REG_TO_SIGNED(data->ch[2]);/* differential */
+                                break;
+                        case 3:
+                                if (((data->control_byte & PCF8591_CONTROL_BYTE_AIP) == 0)
+                                   | ((data->control_byte & PCF8591_CONTROL_BYTE_AIP) == 2))
+                                        results[0] = data->ch[3]; /* single ended */
+                                else
+                                        results[0] = 0;  /* channel not used */
+                                break;
+                }
+        *nrels_mag = 1;
+        }
+}
+
+void pcf8591_aout_enable(struct i2c_client *client, int operation, int ctl_name,
+             int *nrels_mag, long *results)
+{
+        struct pcf8591_data *data = client->data;
+
+        if (operation == SENSORS_PROC_REAL_INFO)
+                *nrels_mag = 0;
+        else if (operation == SENSORS_PROC_REAL_READ) {
+                results[0] = !(!(data->control_byte & PCF8591_CONTROL_BYTE_AOEF));
+                *nrels_mag = 1;
+        } else if (operation == SENSORS_PROC_REAL_WRITE) {
+                if (*nrels_mag >= 1) {
+                        if (results[0])
+                                data->control_byte |= PCF8591_CONTROL_BYTE_AOEF;
+                        else
+                                data->control_byte &= ~PCF8591_CONTROL_BYTE_AOEF;
+
+                        i2c_smbus_write_byte(client, data->control_byte);
+                }
+        }
+}
+
+void pcf8591_aout(struct i2c_client *client, int operation, int ctl_name,
+             int *nrels_mag, long *results)
+{
+        struct pcf8591_data *data = client->data;
+
+        if (operation == SENSORS_PROC_REAL_INFO)
+                *nrels_mag = 0;
+        else if (operation == SENSORS_PROC_REAL_READ) {
+                results[0] = data->aout;
+                *nrels_mag = 1;
+        } else if (operation == SENSORS_PROC_REAL_WRITE) {
+                if (*nrels_mag >= 1) {
+                        if (results[0] >= 0 && results[0] <= 255) /* ignore values outside DAC range */
+                        {
+                                data->aout = results[0];
+                                i2c_smbus_write_byte_data(client, data->control_byte, data->aout);
+                        }
+                }
+        }
+}
+
+static int __init sm_pcf8591_init(void)
+{
+        printk(KERN_INFO "pcf8591.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       return i2c_add_driver(&pcf8591_driver);
+}
+
+static void __exit sm_pcf8591_exit(void)
+{
+        i2c_del_driver(&pcf8591_driver);
+}
+
+
+
+MODULE_AUTHOR("Aurelien Jarno <aurelien@aurel32.net>");
+MODULE_DESCRIPTION("PCF8591 driver");
+MODULE_LICENSE("GPL");
+
+module_init(sm_pcf8591_init);
+module_exit(sm_pcf8591_exit);
--- linux-old/drivers/sensors/sis5595.c Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/sis5595.c     Mon Dec 13 20:18:52 2004
@@ -0,0 +1,735 @@
+/*
+    sis5595.c - Part of lm_sensors, Linux kernel modules
+                for hardware monitoring
+                
+    Copyright (c) 1998 - 2001 Frodo Looijaard <frodol@dds.nl>,
+                        Kyösti Mälkki <kmalkki@cc.hut.fi>, and
+                       Mark D. Studebaker <mdsxyz123@yahoo.com>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/* 
+    Supports following revisions:
+       Version         PCI ID          PCI Revision
+       1               1039/0008       AF or less
+       2               1039/0008       B0 or greater
+
+   Note: these chips contain a 0008 device which is incompatible with the
+         5595. We recognize these by the presence of the listed
+         "blacklist" PCI ID and refuse to load.
+
+   NOT SUPPORTED       PCI ID          BLACKLIST PCI ID        
+        540            0008            0540
+        550            0008            0550
+       5513            0008            5511
+       5581            0008            5597
+       5582            0008            5597
+       5597            0008            5597
+       5598            0008            5597/5598
+        630            0008            0630
+        645            0008            0645
+        730            0008            0730
+        735            0008            0735
+*/
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/ioport.h>
+#include <linux/pci.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#include <asm/io.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+MODULE_LICENSE("GPL");
+
+/* If force_addr is set to anything different from 0, we forcibly enable
+   the device at the given address. */
+static int force_addr = 0;
+MODULE_PARM(force_addr, "i");
+MODULE_PARM_DESC(force_addr,
+                "Initialize the base address of the sensors");
+
+/* Addresses to scan.
+   Note that we can't determine the ISA address until we have initialized
+   our module */
+static unsigned short normal_i2c[] = { SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { SENSORS_I2C_END };
+static unsigned int normal_isa[] = { 0x0000, SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+/* Insmod parameters */
+SENSORS_INSMOD_1(sis5595);
+
+static int blacklist[] = {
+                       PCI_DEVICE_ID_SI_540,
+                       PCI_DEVICE_ID_SI_550,
+                       PCI_DEVICE_ID_SI_630,
+                       PCI_DEVICE_ID_SI_730,
+                       PCI_DEVICE_ID_SI_5511, /* 5513 chip has the 0008 device but
+                                                 that ID shows up in other chips so we
+                                                 use the 5511 ID for recognition */
+                       PCI_DEVICE_ID_SI_5597,
+                       PCI_DEVICE_ID_SI_5598,
+                       0x645,
+                       0x735,
+                          0 };
+/*
+   SiS southbridge has a LM78-like chip integrated on the same IC.
+   This driver is a customized copy of lm78.c
+*/
+
+/* Many SIS5595 constants specified below */
+
+/* Length of ISA address segment */
+#define SIS5595_EXTENT 8
+/* PCI Config Registers */
+#define SIS5595_REVISION_REG 0x08
+#define SIS5595_BASE_REG 0x68
+#define SIS5595_PIN_REG 0x7A
+#define SIS5595_ENABLE_REG 0x7B
+
+/* Where are the ISA address/data registers relative to the base address */
+#define SIS5595_ADDR_REG_OFFSET 5
+#define SIS5595_DATA_REG_OFFSET 6
+
+/* The SIS5595 registers */
+#define SIS5595_REG_IN_MAX(nr) (0x2b + (nr) * 2)
+#define SIS5595_REG_IN_MIN(nr) (0x2c + (nr) * 2)
+#define SIS5595_REG_IN(nr) (0x20 + (nr))
+
+#define SIS5595_REG_FAN_MIN(nr) (0x3a + (nr))
+#define SIS5595_REG_FAN(nr) (0x27 + (nr))
+
+/* On the first version of the chip, the temp registers are separate.
+   On the second version,
+   TEMP pin is shared with IN4, configured in PCI register 0x7A.
+   The registers are the same as well.
+   OVER and HYST are really MAX and MIN. */
+
+#define REV2MIN        0xb0
+#define SIS5595_REG_TEMP       (( data->revision) >= REV2MIN) ? \
+                                       SIS5595_REG_IN(4) : 0x27
+#define SIS5595_REG_TEMP_OVER  (( data->revision) >= REV2MIN) ? \
+                                       SIS5595_REG_IN_MAX(4) : 0x39
+#define SIS5595_REG_TEMP_HYST  (( data->revision) >= REV2MIN) ? \
+                                       SIS5595_REG_IN_MIN(4) : 0x3a
+
+#define SIS5595_REG_CONFIG 0x40
+#define SIS5595_REG_ALARM1 0x41
+#define SIS5595_REG_ALARM2 0x42
+#define SIS5595_REG_FANDIV 0x47
+
+/* Conversions. Limit checking is only done on the TO_REG
+   variants. Note that you should be a bit careful with which arguments
+   these macros are called: arguments may be evaluated more than once.
+   Fixing this is just not worth it. */
+
+#define IN_TO_REG(val)  (SENSORS_LIMIT((((val) * 10 + 8)/16),0,255))
+#define IN_FROM_REG(val) (((val) *  16 + 5) / 10)
+
+static inline u8 FAN_TO_REG(long rpm, int div)
+{
+       if (rpm == 0)
+               return 255;
+       rpm = SENSORS_LIMIT(rpm, 1, 1000000);
+       return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1,
+                            254);
+}
+
+#define FAN_FROM_REG(val,div) ((val)==0?-1:(val)==255?0:1350000/((val)*(div)))
+
+/* Version 1 datasheet temp=.83*reg + 52.12 */
+#define TEMP_FROM_REG(val) (((((val)>=0x80?(val)-0x100:(val))*83)+5212)/10)
+/* inverse 1.20*val - 62.77 */
+#define TEMP_TO_REG(val) (SENSORS_LIMIT(((val)<0?\
+                               ((((val)*12)-6327)/100):\
+                                ((((val)*12)-6227)/100)),0,255))
+
+#define ALARMS_FROM_REG(val) (val)
+
+#define DIV_FROM_REG(val) (1 << (val))
+#define DIV_TO_REG(val) ((val)==8?3:(val)==4?2:(val)==1?0:1)
+
+/* For the SIS5595, we need to keep some data in memory. That
+   data is pointed to by sis5595_list[NR]->data. The structure itself is
+   dynamically allocated, at the time when the new sis5595 client is
+   allocated. */
+struct sis5595_data {
+       struct i2c_client client;
+       struct semaphore lock;
+       int sysctl_id;
+
+       struct semaphore update_lock;
+       char valid;             /* !=0 if following fields are valid */
+       unsigned long last_updated;     /* In jiffies */
+       char maxins;            /* == 3 if temp enabled, otherwise == 4 */
+       u8 revision;            /* Reg. value */
+
+       u8 in[5];               /* Register value */
+       u8 in_max[5];           /* Register value */
+       u8 in_min[5];           /* Register value */
+       u8 fan[2];              /* Register value */
+       u8 fan_min[2];          /* Register value */
+       u8 temp;                /* Register value */
+       u8 temp_over;           /* Register value  - really max */
+       u8 temp_hyst;           /* Register value  - really min */
+       u8 fan_div[2];          /* Register encoding, shifted right */
+       u16 alarms;             /* Register encoding, combined */
+};
+
+static struct pci_dev *s_bridge;       /* pointer to the (only) sis5595 */
+
+static int sis5595_attach_adapter(struct i2c_adapter *adapter);
+static int sis5595_detect(struct i2c_adapter *adapter, int address,
+                         unsigned short flags, int kind);
+static int sis5595_detach_client(struct i2c_client *client);
+
+static int sis5595_read_value(struct i2c_client *client, u8 register);
+static int sis5595_write_value(struct i2c_client *client, u8 register,
+                              u8 value);
+static void sis5595_update_client(struct i2c_client *client);
+static void sis5595_init_client(struct i2c_client *client);
+static int sis5595_find_sis(int *address);
+
+
+static void sis5595_in(struct i2c_client *client, int operation,
+                      int ctl_name, int *nrels_mag, long *results);
+static void sis5595_fan(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void sis5595_temp(struct i2c_client *client, int operation,
+                        int ctl_name, int *nrels_mag, long *results);
+static void sis5595_alarms(struct i2c_client *client, int operation,
+                          int ctl_name, int *nrels_mag, long *results);
+static void sis5595_fan_div(struct i2c_client *client, int operation,
+                           int ctl_name, int *nrels_mag, long *results);
+
+static int sis5595_id = 0;
+
+/* The driver. I choose to use type i2c_driver, as at is identical to both
+   smbus_driver and isa_driver, and clients could be of either kind */
+static struct i2c_driver sis5595_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "SiS 5595",
+       .id             = I2C_DRIVERID_SIS5595,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = sis5595_attach_adapter,
+       .detach_client  = sis5595_detach_client,
+};
+
+/* The /proc/sys entries */
+
+/* -- SENSORS SYSCTL START -- */
+#define SIS5595_SYSCTL_IN0 1000        /* Volts * 100 */
+#define SIS5595_SYSCTL_IN1 1001
+#define SIS5595_SYSCTL_IN2 1002
+#define SIS5595_SYSCTL_IN3 1003
+#define SIS5595_SYSCTL_IN4 1004
+#define SIS5595_SYSCTL_FAN1 1101       /* Rotations/min */
+#define SIS5595_SYSCTL_FAN2 1102
+#define SIS5595_SYSCTL_TEMP 1200       /* Degrees Celcius * 10 */
+#define SIS5595_SYSCTL_FAN_DIV 2000    /* 1, 2, 4 or 8 */
+#define SIS5595_SYSCTL_ALARMS 2001     /* bitvector */
+
+#define SIS5595_ALARM_IN0 0x01
+#define SIS5595_ALARM_IN1 0x02
+#define SIS5595_ALARM_IN2 0x04
+#define SIS5595_ALARM_IN3 0x08
+#define SIS5595_ALARM_BTI 0x20
+#define SIS5595_ALARM_FAN1 0x40
+#define SIS5595_ALARM_FAN2 0x80
+#define SIS5595_ALARM_IN4  0x8000
+#define SIS5595_ALARM_TEMP 0x8000
+
+/* -- SENSORS SYSCTL END -- */
+
+/* These files are created for each detected SIS5595. This is just a template;
+   though at first sight, you might think we could use a statically
+   allocated list, we need some way to get back to the parent - which
+   is done through one of the 'extra' fields which are initialized 
+   when a new copy is allocated. */
+static ctl_table sis5595_dir_table_template[] = {
+       {SIS5595_SYSCTL_IN0, "in0", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &sis5595_in},
+       {SIS5595_SYSCTL_IN1, "in1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &sis5595_in},
+       {SIS5595_SYSCTL_IN2, "in2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &sis5595_in},
+       {SIS5595_SYSCTL_IN3, "in3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &sis5595_in},
+       {SIS5595_SYSCTL_IN4, "in4", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &sis5595_in},
+       {SIS5595_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &sis5595_fan},
+       {SIS5595_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &sis5595_fan},
+       {SIS5595_SYSCTL_TEMP, "temp", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &sis5595_temp},
+       {SIS5595_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &sis5595_fan_div},
+       {SIS5595_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &sis5595_alarms},
+       {0}
+};
+
+/* This is called when the module is loaded */
+static int sis5595_attach_adapter(struct i2c_adapter *adapter)
+{
+       return i2c_detect(adapter, &addr_data, sis5595_detect);
+}
+
+/* Locate SiS bridge and correct base address for SIS5595 */
+static int sis5595_find_sis(int *address)
+{
+       u16 val;
+       int *i;
+
+       if (!pci_present())
+               return -ENODEV;
+
+       if (!(s_bridge =
+             pci_find_device(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_503,
+                            NULL)))
+               return -ENODEV;
+
+       /* Look for imposters */
+       for(i = blacklist; *i != 0; i++) {
+               if (pci_find_device(PCI_VENDOR_ID_SI, *i, NULL)) {
+                       printk("sis5595.o: Error: Looked for SIS5595 but found unsupported device %.4X\n", *i);
+                       return -ENODEV;
+               }
+       }
+
+       if (PCIBIOS_SUCCESSFUL !=
+           pci_read_config_word(s_bridge, SIS5595_BASE_REG, &val))
+               return -ENODEV;
+
+       *address = val & ~(SIS5595_EXTENT - 1);
+       if (*address == 0 && force_addr == 0) {
+               printk("sis5595.o: base address not set - upgrade BIOS or use force_addr=0xaddr\n");
+               return -ENODEV;
+       }
+       if (force_addr)
+               *address = force_addr;  /* so detect will get called */
+
+       return 0;
+}
+
+int sis5595_detect(struct i2c_adapter *adapter, int address,
+                  unsigned short flags, int kind)
+{
+       int i;
+       struct i2c_client *new_client;
+       struct sis5595_data *data;
+       int err = 0;
+       const char *type_name = "sis5595";
+       const char *client_name = "SIS5595 chip";
+       char val;
+       u16 a;
+
+       /* Make sure we are probing the ISA bus!!  */
+       if (!i2c_is_isa_adapter(adapter)) {
+               printk
+                   ("sis5595.o: sis5595_detect called for an I2C bus adapter?!?\n");
+               return 0;
+       }
+
+       if(force_addr)
+               address = force_addr & ~(SIS5595_EXTENT - 1);
+       if (check_region(address, SIS5595_EXTENT)) {
+               printk("sis5595.o: region 0x%x already in use!\n", address);
+               return -ENODEV;
+       }
+       if(force_addr) {
+               printk("sis5595.o: forcing ISA address 0x%04X\n", address);
+               if (PCIBIOS_SUCCESSFUL !=
+                   pci_write_config_word(s_bridge, SIS5595_BASE_REG, address))
+                       return -ENODEV;
+               if (PCIBIOS_SUCCESSFUL !=
+                   pci_read_config_word(s_bridge, SIS5595_BASE_REG, &a))
+                       return -ENODEV;
+               if ((a & ~(SIS5595_EXTENT - 1)) != address) {
+                       /* doesn't work for some chips? */
+                       printk("sis5595.o: force address failed\n");
+                       return -ENODEV;
+               }
+       }
+
+       if (PCIBIOS_SUCCESSFUL !=
+           pci_read_config_byte(s_bridge, SIS5595_ENABLE_REG, &val))
+               return -ENODEV;
+       if((val & 0x80) == 0) {
+               printk("sis5595.o: enabling sensors\n");
+               if (PCIBIOS_SUCCESSFUL !=
+                   pci_write_config_byte(s_bridge, SIS5595_ENABLE_REG,
+                                     val | 0x80))
+                       return -ENODEV;
+               if (PCIBIOS_SUCCESSFUL !=
+                   pci_read_config_byte(s_bridge, SIS5595_ENABLE_REG, &val))
+                       return -ENODEV;
+               if((val & 0x80) == 0) { /* doesn't work for some chips! */
+                       printk("sis5595.o: sensors enable failed - not supported?\n");
+                       return -ENODEV;
+               }
+       }
+
+       if (!(data = kmalloc(sizeof(struct sis5595_data), GFP_KERNEL))) {
+               return -ENOMEM;
+       }
+
+       new_client = &data->client;
+       new_client->addr = address;
+       init_MUTEX(&data->lock);
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &sis5595_driver;
+       new_client->flags = 0;
+
+       /* Reserve the ISA region */
+       request_region(address, SIS5595_EXTENT, type_name);
+
+       /* Check revision and pin registers to determine whether 3 or 4 voltages */
+       pci_read_config_byte(s_bridge, SIS5595_REVISION_REG, &(data->revision));
+       if(data->revision < REV2MIN) {
+               data->maxins = 3;
+       } else {
+               pci_read_config_byte(s_bridge, SIS5595_PIN_REG, &val);
+               if(val & 0x80)
+                       /* 3 voltages, 1 temp */
+                       data->maxins = 3;
+               else
+                       /* 4 voltages, no temps */
+                       data->maxins = 4;
+       }
+
+       /* Fill in the remaining client fields and put it into the global list */
+       strcpy(new_client->name, client_name);
+
+       new_client->id = sis5595_id++;
+       data->valid = 0;
+       init_MUTEX(&data->update_lock);
+
+       /* Tell the I2C layer a new client has arrived */
+       if ((err = i2c_attach_client(new_client)))
+               goto ERROR3;
+
+       /* Register a new directory entry with module sensors */
+       if ((i = i2c_register_entry((struct i2c_client *) new_client,
+                                       type_name,
+                                       sis5595_dir_table_template)) < 0) {
+               err = i;
+               goto ERROR4;
+       }
+       data->sysctl_id = i;
+
+       /* Initialize the SIS5595 chip */
+       sis5595_init_client(new_client);
+       return 0;
+
+      ERROR4:
+       i2c_detach_client(new_client);
+      ERROR3:
+       release_region(address, SIS5595_EXTENT);
+       kfree(data);
+       return err;
+}
+
+static int sis5595_detach_client(struct i2c_client *client)
+{
+       int err;
+
+       i2c_deregister_entry(((struct sis5595_data *) (client->data))->
+                                sysctl_id);
+
+       if ((err = i2c_detach_client(client))) {
+               printk
+                   ("sis5595.o: Client deregistration failed, client not detached.\n");
+               return err;
+       }
+
+       release_region(client->addr, SIS5595_EXTENT);
+       kfree(client->data);
+
+       return 0;
+}
+
+
+/* ISA access must be locked explicitly.
+   There are some ugly typecasts here, but the good news is - they should
+   nowhere else be necessary! */
+static int sis5595_read_value(struct i2c_client *client, u8 reg)
+{
+       int res;
+
+       down(&(((struct sis5595_data *) (client->data))->lock));
+       outb_p(reg, client->addr + SIS5595_ADDR_REG_OFFSET);
+       res = inb_p(client->addr + SIS5595_DATA_REG_OFFSET);
+       up(&(((struct sis5595_data *) (client->data))->lock));
+       return res;
+}
+
+static int sis5595_write_value(struct i2c_client *client, u8 reg, u8 value)
+{
+       down(&(((struct sis5595_data *) (client->data))->lock));
+       outb_p(reg, client->addr + SIS5595_ADDR_REG_OFFSET);
+       outb_p(value, client->addr + SIS5595_DATA_REG_OFFSET);
+       up(&(((struct sis5595_data *) (client->data))->lock));
+       return 0;
+}
+
+/* Called when we have found a new SIS5595. */
+static void sis5595_init_client(struct i2c_client *client)
+{
+       u8 reg;
+
+       /* Start monitoring */
+       reg = i2c_smbus_read_byte_data(client, SIS5595_REG_CONFIG);
+       sis5595_write_value(client, SIS5595_REG_CONFIG, (reg|0x01)&0x7F);
+}
+
+static void sis5595_update_client(struct i2c_client *client)
+{
+       struct sis5595_data *data = client->data;
+       int i;
+
+       down(&data->update_lock);
+
+       if ((jiffies - data->last_updated > HZ + HZ / 2) ||
+           (jiffies < data->last_updated) || !data->valid) {
+
+               for (i = 0; i <= data->maxins; i++) {
+                       data->in[i] =
+                           sis5595_read_value(client, SIS5595_REG_IN(i));
+                       data->in_min[i] =
+                           sis5595_read_value(client,
+                                              SIS5595_REG_IN_MIN(i));
+                       data->in_max[i] =
+                           sis5595_read_value(client,
+                                              SIS5595_REG_IN_MAX(i));
+               }
+               for (i = 1; i <= 2; i++) {
+                       data->fan[i - 1] =
+                           sis5595_read_value(client, SIS5595_REG_FAN(i));
+                       data->fan_min[i - 1] =
+                           sis5595_read_value(client,
+                                              SIS5595_REG_FAN_MIN(i));
+               }
+               if(data->maxins == 3) {
+                       data->temp =
+                           sis5595_read_value(client, SIS5595_REG_TEMP);
+                       data->temp_over =
+                           sis5595_read_value(client, SIS5595_REG_TEMP_OVER);
+                       data->temp_hyst =
+                           sis5595_read_value(client, SIS5595_REG_TEMP_HYST);
+               }
+               i = sis5595_read_value(client, SIS5595_REG_FANDIV);
+               data->fan_div[0] = (i >> 4) & 0x03;
+               data->fan_div[1] = i >> 6;
+               data->alarms =
+                   sis5595_read_value(client, SIS5595_REG_ALARM1) |
+                   (sis5595_read_value(client, SIS5595_REG_ALARM2) << 8);
+               data->last_updated = jiffies;
+               data->valid = 1;
+       }
+
+       up(&data->update_lock);
+}
+
+
+/* The next few functions are the call-back functions of the /proc/sys and
+   sysctl files. Which function is used is defined in the ctl_table in
+   the extra1 field.
+   Each function must return the magnitude (power of 10 to divide the date
+   with) if it is called with operation==SENSORS_PROC_REAL_INFO. It must
+   put a maximum of *nrels elements in results reflecting the data of this
+   file, and set *nrels to the number it actually put in it, if operation==
+   SENSORS_PROC_REAL_READ. Finally, it must get upto *nrels elements from
+   results and write them to the chip, if operations==SENSORS_PROC_REAL_WRITE.
+   Note that on SENSORS_PROC_REAL_READ, I do not check whether results is
+   large enough (by checking the incoming value of *nrels). This is not very
+   good practice, but as long as you put less than about 5 values in results,
+   you can assume it is large enough. */
+
+/* Return 0 for in4 and disallow writes if pin used for temp */
+void sis5595_in(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       struct sis5595_data *data = client->data;
+       int nr = ctl_name - SIS5595_SYSCTL_IN0;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 2;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               if(nr <= 3 || data->maxins == 4) {
+                       sis5595_update_client(client);
+                       results[0] = IN_FROM_REG(data->in_min[nr]);
+                       results[1] = IN_FROM_REG(data->in_max[nr]);
+                       results[2] = IN_FROM_REG(data->in[nr]);
+               } else {
+                       results[0] = 0;
+                       results[1] = 0;
+                       results[2] = 0;
+               }
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if(nr <= 3 || data->maxins == 4) {
+                       if (*nrels_mag >= 1) {
+                               data->in_min[nr] = IN_TO_REG(results[0]);
+                               sis5595_write_value(client,
+                                   SIS5595_REG_IN_MIN(nr), data->in_min[nr]);
+                       }
+                       if (*nrels_mag >= 2) {
+                               data->in_max[nr] = IN_TO_REG(results[1]);
+                               sis5595_write_value(client,
+                                   SIS5595_REG_IN_MAX(nr), data->in_max[nr]);
+                       }
+               }
+       }
+}
+
+void sis5595_fan(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct sis5595_data *data = client->data;
+       int nr = ctl_name - SIS5595_SYSCTL_FAN1 + 1;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               sis5595_update_client(client);
+               results[0] = FAN_FROM_REG(data->fan_min[nr - 1],
+                                         DIV_FROM_REG(data->fan_div[nr - 1]));
+               results[1] = FAN_FROM_REG(data->fan[nr - 1],
+                                         DIV_FROM_REG(data->fan_div[nr - 1]));
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->fan_min[nr - 1] = FAN_TO_REG(results[0],
+                                                          DIV_FROM_REG
+                                                          (data->
+                                                           fan_div[nr-1]));
+                       sis5595_write_value(client,
+                                           SIS5595_REG_FAN_MIN(nr),
+                                           data->fan_min[nr - 1]);
+               }
+       }
+}
+
+
+/* Return 0 for temp and disallow writes if pin used for in4 */
+void sis5595_temp(struct i2c_client *client, int operation, int ctl_name,
+                 int *nrels_mag, long *results)
+{
+       struct sis5595_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               if(data->maxins == 3) {
+                       sis5595_update_client(client);
+                       results[0] = TEMP_FROM_REG(data->temp_over);
+                       results[1] = TEMP_FROM_REG(data->temp_hyst);
+                       results[2] = TEMP_FROM_REG(data->temp);
+               } else {
+                       results[0] = 0;
+                       results[1] = 0;
+                       results[2] = 0;
+               }
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if(data->maxins == 3) {
+                       if (*nrels_mag >= 1) {
+                               data->temp_over = TEMP_TO_REG(results[0]);
+                               sis5595_write_value(client,
+                                   SIS5595_REG_TEMP_OVER, data->temp_over);
+                       }
+                       if (*nrels_mag >= 2) {
+                               data->temp_hyst = TEMP_TO_REG(results[1]);
+                               sis5595_write_value(client,
+                                   SIS5595_REG_TEMP_HYST, data->temp_hyst);
+                       }
+               }
+       }
+}
+
+void sis5595_alarms(struct i2c_client *client, int operation, int ctl_name,
+                   int *nrels_mag, long *results)
+{
+       struct sis5595_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               sis5595_update_client(client);
+               results[0] = ALARMS_FROM_REG(data->alarms);
+               *nrels_mag = 1;
+       }
+}
+
+void sis5595_fan_div(struct i2c_client *client, int operation,
+                    int ctl_name, int *nrels_mag, long *results)
+{
+       struct sis5595_data *data = client->data;
+       int old;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               sis5595_update_client(client);
+               results[0] = DIV_FROM_REG(data->fan_div[0]);
+               results[1] = DIV_FROM_REG(data->fan_div[1]);
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               old = sis5595_read_value(client, SIS5595_REG_FANDIV);
+               if (*nrels_mag >= 2) {
+                       data->fan_div[1] = DIV_TO_REG(results[1]);
+                       old = (old & 0x3f) | (data->fan_div[1] << 6);
+               }
+               if (*nrels_mag >= 1) {
+                       data->fan_div[0] = DIV_TO_REG(results[0]);
+                       old = (old & 0xcf) | (data->fan_div[0] << 4);
+                       sis5595_write_value(client, SIS5595_REG_FANDIV, old);
+               }
+       }
+}
+
+static int __init sm_sis5595_init(void)
+{
+       int addr;
+
+       printk("sis5595.o version %s (%s)\n", LM_VERSION, LM_DATE);
+
+       if (sis5595_find_sis(&addr)) {
+               printk("sis5595.o: SIS5595 not detected, module not inserted.\n");
+               return -ENODEV;
+       }
+       normal_isa[0] = addr;
+
+       return i2c_add_driver(&sis5595_driver);
+}
+
+static void __exit sm_sis5595_exit(void)
+{
+       i2c_del_driver(&sis5595_driver);
+}
+
+
+
+MODULE_AUTHOR("Kyösti Mälkki <kmalkki@cc.hut.fi>");
+MODULE_DESCRIPTION("SiS 5595 Sensor device");
+
+module_init(sm_sis5595_init);
+module_exit(sm_sis5595_exit);
--- linux-old/drivers/sensors/smsc47m1.c        Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/smsc47m1.c    Mon Dec 13 20:18:52 2004
@@ -0,0 +1,515 @@
+/*
+    smsc47m1.c - Part of lm_sensors, Linux kernel modules
+                for hardware monitoring
+                
+    Copyright (c) 2002 Mark D. Studebaker <mdsxyz123@yahoo.com>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/ioport.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#include <asm/io.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+static int force_addr = 0;
+MODULE_PARM(force_addr, "i");
+MODULE_PARM_DESC(force_addr,
+                "Initialize the base address of the sensors");
+
+static unsigned short normal_i2c[] = { SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { SENSORS_I2C_END };
+static unsigned int normal_isa[] = { 0x0000, SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+SENSORS_INSMOD_1(smsc47m1);
+
+/* modified from kernel/include/traps.c */
+#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    0x0a    /* The device with the fan registers in it */
+#define        DEVID   0x20    /* Register: Device ID */
+
+static inline void
+superio_outb(int reg, int val)
+{
+       outb(reg, REG);
+       outb(val, VAL);
+}
+
+static inline int
+superio_inb(int reg)
+{
+       outb(reg, REG);
+       return inb(VAL);
+}
+
+static inline void
+superio_select(void)
+{
+       outb(DEV, REG);
+       outb(PME, VAL);
+}
+
+static inline void
+superio_enter(void)
+{
+       outb(0x55, REG);
+}
+
+static inline void
+superio_exit(void)
+{
+       outb(0xAA, REG);
+}
+
+/*
+ * SMSC LPC47M10x (device id 0x59), LPC47M14x (device id 0x5F) and
+ * LPC47B27x (device id 0x51) have fan control.
+ * The 47M15x and 47M192 chips "with hardware monitoring block"
+ * can do much more besides (device id 0x60).
+ */
+#define SMSC_DEVID_MATCH(id) ((id) == 0x51 || (id) == 0x59 || (id) == 0x5F)
+
+#define SMSC_ACT_REG 0x30
+#define SMSC_BASE_REG 0x60
+
+#define SMSC_EXTENT 0x80
+
+#define SMSC47M1_REG_ALARM1 0x04
+#define SMSC47M1_REG_TPIN2 0x33
+#define SMSC47M1_REG_TPIN1 0x34
+#define SMSC47M1_REG_PPIN(nr) (0x37 - (nr))
+#define SMSC47M1_REG_PWM(nr) (0x55 + (nr))
+#define SMSC47M1_REG_FANDIV 0x58
+#define SMSC47M1_REG_FAN(nr) (0x58 + (nr))
+#define SMSC47M1_REG_FAN_MIN(nr) (0x5a + (nr))
+
+static inline u8 MIN_TO_REG(long rpm, int div)
+{
+       if (rpm == 0)
+               return 0;
+       rpm = SENSORS_LIMIT(rpm, 1, 1000000);
+       return SENSORS_LIMIT(192 - ((983040 + rpm * div / 2) / (rpm * div)),
+                            0, 191);
+}
+
+#define MIN_FROM_REG(val,div) ((val)>=192?0: \
+                                983040/((192-(val))*(div)))
+#define FAN_FROM_REG(val,div,preload) ((val)==0?-1:(val)==255?0: \
+                                983040/(((val)-preload)*(div)))
+#define DIV_FROM_REG(val) (1 << (val))
+#define DIV_TO_REG(val) ((val)==8?3:(val)==4?2:(val)==1?0:1)
+/* reg is 6 middle bits; /proc is 8 bits */
+#define PWM_FROM_REG(val) (((val) << 1) & 0xfc)
+#define PWM_TO_REG(val)   (((SENSORS_LIMIT((val), 0, 255)) >> 1) & 0x7e)
+
+struct smsc47m1_data {
+       struct i2c_client client;
+       struct semaphore lock;
+       int sysctl_id;
+
+       struct semaphore update_lock;
+       char valid;             /* !=0 if following fields are valid */
+       unsigned long last_updated;     /* In jiffies */
+
+       u8 fan[2];              /* Register value */
+       u8 fan_min[2];          /* Register value */
+       u8 fan_div[2];          /* Register encoding, shifted right */
+       u8 alarms;              /* Register encoding */
+       u8 pwm[2];              /* Register value (bit 7 is enable) */
+};
+
+
+static int smsc47m1_attach_adapter(struct i2c_adapter *adapter);
+static int smsc47m1_detect(struct i2c_adapter *adapter, int address,
+                         unsigned short flags, int kind);
+static int smsc47m1_detach_client(struct i2c_client *client);
+
+static int smsc47m1_read_value(struct i2c_client *client, u8 register);
+static int smsc47m1_write_value(struct i2c_client *client, u8 register,
+                              u8 value);
+static void smsc47m1_update_client(struct i2c_client *client);
+static void smsc47m1_init_client(struct i2c_client *client);
+static int smsc47m1_find(int *address);
+
+
+static void smsc47m1_fan(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void smsc47m1_alarms(struct i2c_client *client, int operation,
+                          int ctl_name, int *nrels_mag, long *results);
+static void smsc47m1_fan_div(struct i2c_client *client, int operation,
+                           int ctl_name, int *nrels_mag, long *results);
+static void smsc47m1_pwm(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+
+static int smsc47m1_id = 0;
+
+static struct i2c_driver smsc47m1_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "SMSC 47M1xx fan monitor",
+       .id             = I2C_DRIVERID_SMSC47M1,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = smsc47m1_attach_adapter,
+       .detach_client  = smsc47m1_detach_client,
+};
+
+/* -- SENSORS SYSCTL START -- */
+#define SMSC47M1_SYSCTL_FAN1 1101   /* Rotations/min */
+#define SMSC47M1_SYSCTL_FAN2 1102
+#define SMSC47M1_SYSCTL_PWM1 1401
+#define SMSC47M1_SYSCTL_PWM2 1402
+#define SMSC47M1_SYSCTL_FAN_DIV 2000        /* 1, 2, 4 or 8 */
+#define SMSC47M1_SYSCTL_ALARMS 2004    /* bitvector */
+
+#define SMSC47M1_ALARM_FAN1 0x0001
+#define SMSC47M1_ALARM_FAN2 0x0002
+
+/* -- SENSORS SYSCTL END -- */
+
+static ctl_table smsc47m1_dir_table_template[] = {
+       {SMSC47M1_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &smsc47m1_fan},
+       {SMSC47M1_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &smsc47m1_fan},
+       {SMSC47M1_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &smsc47m1_fan_div},
+       {SMSC47M1_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &smsc47m1_alarms},
+       {SMSC47M1_SYSCTL_PWM1, "pwm1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &smsc47m1_pwm},
+       {SMSC47M1_SYSCTL_PWM2, "pwm2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &smsc47m1_pwm},
+       {0}
+};
+
+static int smsc47m1_attach_adapter(struct i2c_adapter *adapter)
+{
+       return i2c_detect(adapter, &addr_data, smsc47m1_detect);
+}
+
+static int smsc47m1_find(int *address)
+{
+       u16 val;
+
+       superio_enter();
+       val= superio_inb(DEVID);
+       if (!SMSC_DEVID_MATCH(val)) {
+               superio_exit();
+               return -ENODEV;
+       }
+
+       superio_select();
+       val = (superio_inb(SMSC_BASE_REG) << 8) |
+              superio_inb(SMSC_BASE_REG + 1);
+       *address = val & ~(SMSC_EXTENT - 1);
+       if (*address == 0 && force_addr == 0) {
+               printk("smsc47m1.o: base address not set - use force_addr=0xaddr\n");
+               superio_exit();
+               return -ENODEV;
+       }
+       if (force_addr)
+               *address = force_addr;  /* so detect will get called */
+
+       superio_exit();
+       return 0;
+}
+
+int smsc47m1_detect(struct i2c_adapter *adapter, int address,
+                  unsigned short flags, int kind)
+{
+       int i;
+       struct i2c_client *new_client;
+       struct smsc47m1_data *data;
+       int err = 0;
+       const char *type_name = "smsc47m1";
+       const char *client_name = "47M1xx chip";
+
+       if (!i2c_is_isa_adapter(adapter)) {
+               return 0;
+       }
+
+       if(force_addr)
+               address = force_addr & ~(SMSC_EXTENT - 1);
+       if (check_region(address, SMSC_EXTENT)) {
+               printk("smsc47m1.o: region 0x%x already in use!\n", address);
+               return -ENODEV;
+       }
+       if(force_addr) {
+               printk("smsc47m1.o: forcing ISA address 0x%04X\n", address);
+               superio_enter();
+               superio_select();
+               superio_outb(SMSC_BASE_REG, address >> 8);
+               superio_outb(SMSC_BASE_REG+1, address & 0xff);
+               superio_exit();
+       }
+
+       if (!(data = kmalloc(sizeof(struct smsc47m1_data), GFP_KERNEL))) {
+               return -ENOMEM;
+       }
+
+       new_client = &data->client;
+       new_client->addr = address;
+       init_MUTEX(&data->lock);
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &smsc47m1_driver;
+       new_client->flags = 0;
+
+       request_region(address, SMSC_EXTENT, "smsc47m1-fans");
+       strcpy(new_client->name, client_name);
+
+       new_client->id = smsc47m1_id++;
+       data->valid = 0;
+       init_MUTEX(&data->update_lock);
+
+       if ((err = i2c_attach_client(new_client)))
+               goto ERROR3;
+
+       if ((i = i2c_register_entry((struct i2c_client *) new_client,
+                                       type_name,
+                                       smsc47m1_dir_table_template)) < 0) {
+               err = i;
+               goto ERROR4;
+       }
+       data->sysctl_id = i;
+
+       smsc47m1_init_client(new_client);
+       return 0;
+
+      ERROR4:
+       i2c_detach_client(new_client);
+      ERROR3:
+       release_region(address, SMSC_EXTENT);
+       kfree(data);
+       return err;
+}
+
+static int smsc47m1_detach_client(struct i2c_client *client)
+{
+       int err;
+
+       i2c_deregister_entry(((struct smsc47m1_data *) (client->data))->
+                                sysctl_id);
+
+       if ((err = i2c_detach_client(client))) {
+               printk
+                   ("smsc47m1.o: Client deregistration failed, client not detached.\n");
+               return err;
+       }
+
+       release_region(client->addr, SMSC_EXTENT);
+       kfree(client->data);
+
+       return 0;
+}
+
+static int smsc47m1_read_value(struct i2c_client *client, u8 reg)
+{
+       int res;
+
+       down(&(((struct smsc47m1_data *) (client->data))->lock));
+       res = inb_p(client->addr + reg);
+       up(&(((struct smsc47m1_data *) (client->data))->lock));
+       return res;
+}
+
+static int smsc47m1_write_value(struct i2c_client *client, u8 reg, u8 value)
+{
+       down(&(((struct smsc47m1_data *) (client->data))->lock));
+       outb_p(value, client->addr + reg);
+       up(&(((struct smsc47m1_data *) (client->data))->lock));
+       return 0;
+}
+
+static void smsc47m1_init_client(struct i2c_client *client)
+{
+       /* configure pins for tach function */
+       smsc47m1_write_value(client, SMSC47M1_REG_TPIN1, 0x05);
+       smsc47m1_write_value(client, SMSC47M1_REG_TPIN2, 0x05);
+}
+
+static void smsc47m1_update_client(struct i2c_client *client)
+{
+       struct smsc47m1_data *data = client->data;
+       int i;
+
+       down(&data->update_lock);
+
+       if ((jiffies - data->last_updated > HZ + HZ / 2) ||
+           (jiffies < data->last_updated) || !data->valid) {
+               for (i = 1; i <= 2; i++) {
+                       data->fan[i - 1] =
+                           smsc47m1_read_value(client, SMSC47M1_REG_FAN(i));
+                       data->fan_min[i - 1] =
+                           smsc47m1_read_value(client, SMSC47M1_REG_FAN_MIN(i));
+                       data->pwm[i - 1] =
+                           smsc47m1_read_value(client, SMSC47M1_REG_PWM(i));
+               }
+
+               i = smsc47m1_read_value(client, SMSC47M1_REG_FANDIV);
+               data->fan_div[0] = (i >> 4) & 0x03;
+               data->fan_div[1] = i >> 6;
+               data->alarms =
+                       smsc47m1_read_value(client, SMSC47M1_REG_ALARM1) >> 6;
+               if(data->alarms)
+                       smsc47m1_write_value(client, SMSC47M1_REG_ALARM1, 0xc0);
+               data->last_updated = jiffies;
+               data->valid = 1;
+       }
+
+       up(&data->update_lock);
+}
+
+
+void smsc47m1_fan(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct smsc47m1_data *data = client->data;
+       int nr = ctl_name - SMSC47M1_SYSCTL_FAN1 + 1;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               smsc47m1_update_client(client);
+               results[0] = MIN_FROM_REG(data->fan_min[nr - 1],
+                                         DIV_FROM_REG(data->fan_div[nr - 1]));
+               results[1] = FAN_FROM_REG(data->fan[nr - 1],
+                                         DIV_FROM_REG(data->fan_div[nr - 1]),
+                                         data->fan_min[nr - 1]);
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->fan_min[nr - 1] = MIN_TO_REG(results[0],
+                                                          DIV_FROM_REG
+                                                          (data->
+                                                           fan_div[nr-1]));
+                       smsc47m1_write_value(client, SMSC47M1_REG_FAN_MIN(nr),
+                                           data->fan_min[nr - 1]);
+               }
+       }
+}
+
+
+void smsc47m1_alarms(struct i2c_client *client, int operation, int ctl_name,
+                   int *nrels_mag, long *results)
+{
+       struct smsc47m1_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               smsc47m1_update_client(client);
+               results[0] = data->alarms;
+               *nrels_mag = 1;
+       }
+}
+
+void smsc47m1_fan_div(struct i2c_client *client, int operation,
+                    int ctl_name, int *nrels_mag, long *results)
+{
+       struct smsc47m1_data *data = client->data;
+       int old;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               smsc47m1_update_client(client);
+               results[0] = DIV_FROM_REG(data->fan_div[0]);
+               results[1] = DIV_FROM_REG(data->fan_div[1]);
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               old = smsc47m1_read_value(client, SMSC47M1_REG_FANDIV);
+               if (*nrels_mag >= 2) {
+                       data->fan_div[1] = DIV_TO_REG(results[1]);
+                       old = (old & 0x3f) | (data->fan_div[1] << 6);
+               }
+               if (*nrels_mag >= 1) {
+                       data->fan_div[0] = DIV_TO_REG(results[0]);
+                       old = (old & 0xcf) | (data->fan_div[0] << 4);
+                       smsc47m1_write_value(client, SMSC47M1_REG_FANDIV, old);
+               }
+       }
+}
+
+void smsc47m1_pwm(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct smsc47m1_data *data = client->data;
+       int nr = 1 + ctl_name - SMSC47M1_SYSCTL_PWM1;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               smsc47m1_update_client(client);
+               results[0] = PWM_FROM_REG(data->pwm[nr - 1]);
+               results[1] = data->pwm[nr - 1] & 0x01;
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->pwm[nr - 1] &= 0x81;
+                       data->pwm[nr - 1] |= PWM_TO_REG(results[0]);
+                       if (*nrels_mag >= 2) {
+                               if(results[1] && (data->pwm[nr-1] & 0x01)) {
+                                       /* enable PWM */
+/* hope BIOS did it already
+                                       smsc47m1_write_value(client,
+                                                 SMSC47M1_REG_PPIN(nr), 0x04);
+*/
+                                       data->pwm[nr - 1] &= 0xfe;
+                               } else if((!results[1]) && (!(data->pwm[nr-1] & 0x01))) {
+                                       /* disable PWM */
+                                       data->pwm[nr - 1] |= 0x01;
+                               }
+                       }
+                       smsc47m1_write_value(client, SMSC47M1_REG_PWM(nr),
+                                            data->pwm[nr - 1]);
+               }
+       }
+}
+
+static int __init sm_smsc47m1_init(void)
+{
+       int addr;
+
+       printk("smsc47m1.o version %s (%s)\n", LM_VERSION, LM_DATE);
+
+       if (smsc47m1_find(&addr)) {
+               printk("smsc47m1.o: SMSC 47M1xx not detected, module not inserted.\n");
+               return -ENODEV;
+       }
+       normal_isa[0] = addr;
+
+       return i2c_add_driver(&smsc47m1_driver);
+}
+
+static void __exit sm_smsc47m1_exit(void)
+{
+       i2c_del_driver(&smsc47m1_driver);
+}
+
+
+
+MODULE_AUTHOR("Mark D. Studebaker <mdsxyz123@yahoo.com>");
+MODULE_DESCRIPTION("SMSC 47M1xx Fan sensors");
+MODULE_LICENSE("GPL");
+
+module_init(sm_smsc47m1_init);
+module_exit(sm_smsc47m1_exit);
--- linux-old/drivers/sensors/thmc50.c  Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/thmc50.c      Mon Dec 13 20:18:52 2004
@@ -0,0 +1,496 @@
+/*
+    thmc50.c - Part of lm_sensors, Linux kernel modules for hardware
+             monitoring
+    Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl> and
+    Philip Edelbrock <phil@netroedge.com>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#define DEBUG 1
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+MODULE_LICENSE("GPL");
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = { SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { 0x2D, 0x2E, SENSORS_I2C_END };
+static unsigned int normal_isa[] = { SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+/* Insmod parameters */
+SENSORS_INSMOD_1(thmc50);
+
+/* Many THMC50 constants specified below */
+
+/* The THMC50 registers */
+#define THMC50_REG_TEMP 0x27
+#define THMC50_REG_CONF 0x40
+#define THMC50_REG_TEMP_HYST 0x3A
+#define THMC50_REG_TEMP_OS 0x39
+
+#define THMC50_REG_TEMP_TRIP 0x13
+#define THMC50_REG_TEMP_REMOTE_TRIP 0x14
+#define THMC50_REG_TEMP_DEFAULT_TRIP 0x17
+#define THMC50_REG_TEMP_REMOTE_DEFAULT_TRIP 0x18
+#define THMC50_REG_ANALOG_OUT 0x19
+#define THMC50_REG_REMOTE_TEMP 0x26
+#define THMC50_REG_REMOTE_TEMP_HYST 0x38
+#define THMC50_REG_REMOTE_TEMP_OS 0x37
+
+#define THMC50_REG_INTER 0x41
+#define THMC50_REG_INTER_MIRROR 0x4C
+#define THMC50_REG_INTER_MASK 0x43
+
+#define THMC50_REG_COMPANY_ID 0x3E
+#define THMC50_REG_DIE_CODE 0x3F
+
+
+/* Conversions. Rounding and limit checking is only done on the TO_REG
+   variants. Note that you should be a bit careful with which arguments
+   these macros are called: arguments may be evaluated more than once.
+   Fixing this is just not worth it. */
+#define TEMP_FROM_REG(val) ((val>127)?val - 0x0100:val)
+#define TEMP_TO_REG(val)   ((val<0)?0x0100+val:val)
+
+/* Each client has this additional data */
+struct thmc50_data {
+       struct i2c_client client;
+       int sysctl_id;
+
+       struct semaphore update_lock;
+       char valid;             /* !=0 if following fields are valid */
+       unsigned long last_updated;     /* In jiffies */
+
+       u16 temp, temp_os, temp_hyst,
+           remote_temp, remote_temp_os, remote_temp_hyst,
+           inter, inter_mask, die_code, analog_out;    /* Register values */
+};
+
+static int thmc50_attach_adapter(struct i2c_adapter *adapter);
+static int thmc50_detect(struct i2c_adapter *adapter, int address,
+                        unsigned short flags, int kind);
+static void thmc50_init_client(struct i2c_client *client);
+static int thmc50_detach_client(struct i2c_client *client);
+
+static int thmc50_read_value(struct i2c_client *client, u8 reg);
+static int thmc50_write_value(struct i2c_client *client, u8 reg,
+                             u16 value);
+static void thmc50_temp(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void thmc50_remote_temp(struct i2c_client *client, int operation,
+                              int ctl_name, int *nrels_mag,
+                              long *results);
+static void thmc50_inter(struct i2c_client *client, int operation,
+                        int ctl_name, int *nrels_mag, long *results);
+static void thmc50_inter_mask(struct i2c_client *client, int operation,
+                             int ctl_name, int *nrels_mag, long *results);
+static void thmc50_die_code(struct i2c_client *client, int operation,
+                           int ctl_name, int *nrels_mag, long *results);
+static void thmc50_analog_out(struct i2c_client *client, int operation,
+                             int ctl_name, int *nrels_mag, long *results);
+static void thmc50_update_client(struct i2c_client *client);
+
+
+/* This is the driver that will be inserted */
+static struct i2c_driver thmc50_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "THMC50 sensor chip driver",
+       .id             = I2C_DRIVERID_THMC50,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = thmc50_attach_adapter,
+       .detach_client  = thmc50_detach_client,
+};
+
+/* -- SENSORS SYSCTL START -- */
+
+#define THMC50_SYSCTL_TEMP 1200        /* Degrees Celcius */
+#define THMC50_SYSCTL_REMOTE_TEMP 1201 /* Degrees Celcius */
+#define THMC50_SYSCTL_INTER 1202
+#define THMC50_SYSCTL_INTER_MASK 1203
+#define THMC50_SYSCTL_DIE_CODE 1204
+#define THMC50_SYSCTL_ANALOG_OUT 1205
+
+/* -- SENSORS SYSCTL END -- */
+
+/* These files are created for each detected THMC50. This is just a template;
+   though at first sight, you might think we could use a statically
+   allocated list, we need some way to get back to the parent - which
+   is done through one of the 'extra' fields which are initialized
+   when a new copy is allocated. */
+static ctl_table thmc50_dir_table_template[] = {
+       {THMC50_SYSCTL_TEMP, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &thmc50_temp},
+       {THMC50_SYSCTL_REMOTE_TEMP, "temp2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &thmc50_remote_temp},
+       {THMC50_SYSCTL_INTER, "inter", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &thmc50_inter},
+       {THMC50_SYSCTL_INTER_MASK, "inter_mask", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &thmc50_inter_mask},
+       {THMC50_SYSCTL_DIE_CODE, "die_code", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &thmc50_die_code},
+       {THMC50_SYSCTL_ANALOG_OUT, "analog_out", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &thmc50_analog_out},
+       {0}
+};
+
+
+static int thmc50_id = 0;
+
+static int thmc50_attach_adapter(struct i2c_adapter *adapter)
+{
+       return i2c_detect(adapter, &addr_data, thmc50_detect);
+}
+
+/* This function is called by i2c_detect */
+int thmc50_detect(struct i2c_adapter *adapter, int address,
+                 unsigned short flags, int kind)
+{
+       int company, i;
+       struct i2c_client *new_client;
+       struct thmc50_data *data;
+       int err = 0;
+       const char *type_name, *client_name;
+
+#ifdef DEBUG
+       printk("thmc50.o: Probing for THMC50 at 0x%2X on bus %d\n",
+              address, adapter->id);
+#endif
+
+       /* Make sure we aren't probing the ISA bus!! This is just a safety check
+          at this moment; i2c_detect really won't call us. */
+#ifdef DEBUG
+       if (i2c_is_isa_adapter(adapter)) {
+               printk
+                   ("thmc50.o: thmc50_detect called for an ISA bus adapter?!?\n");
+               return 0;
+       }
+#endif
+
+       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
+               goto ERROR0;
+
+       /* OK. For now, we presume we have a valid client. We now create the
+          client structure, even though we cannot fill it completely yet.
+          But it allows us to access thmc50_{read,write}_value. */
+       if (!(data = kmalloc(sizeof(struct thmc50_data), GFP_KERNEL))) {
+               err = -ENOMEM;
+               goto ERROR0;
+       }
+
+       new_client = &data->client;
+       new_client->addr = address;
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &thmc50_driver;
+       new_client->flags = 0;
+
+       /* Now, we do the remaining detection. */
+       company =
+           i2c_smbus_read_byte_data(new_client, THMC50_REG_COMPANY_ID);
+
+       if (company != 0x49) {
+#ifdef DEBUG
+               printk
+                   ("thmc50.o: Detect of THMC50 failed (reg 3E: 0x%X)\n",
+                    company);
+#endif
+               goto ERROR1;
+       }
+
+       /* Determine the chip type - only one kind supported! */
+       kind = thmc50;
+
+       if (kind == thmc50) {
+               type_name = "thmc50";
+               client_name = "THMC50 chip";
+       } else {
+#ifdef DEBUG
+               printk("thmc50.o: Internal error: unknown kind (%d)?!?",
+                      kind);
+#endif
+               goto ERROR1;
+       }
+
+       /* Fill in the remaining client fields and put it into the global list */
+       strcpy(new_client->name, client_name);
+
+       new_client->id = thmc50_id++;
+       data->valid = 0;
+       init_MUTEX(&data->update_lock);
+
+       /* Tell the I2C layer a new client has arrived */
+       if ((err = i2c_attach_client(new_client)))
+               goto ERROR3;
+
+       /* Register a new directory entry with module sensors */
+       if ((i = i2c_register_entry(new_client, type_name,
+                                       thmc50_dir_table_template)) < 0) {
+               err = i;
+               goto ERROR4;
+       }
+       data->sysctl_id = i;
+
+       thmc50_init_client(new_client);
+       return 0;
+
+/* OK, this is not exactly good programming practice, usually. But it is
+   very code-efficient in this case. */
+
+      ERROR4:
+       i2c_detach_client(new_client);
+      ERROR3:
+      ERROR1:
+       kfree(data);
+      ERROR0:
+       return err;
+}
+
+static int thmc50_detach_client(struct i2c_client *client)
+{
+       int err;
+
+       i2c_deregister_entry(((struct thmc50_data *) (client->data))->
+                                sysctl_id);
+
+       if ((err = i2c_detach_client(client))) {
+               printk
+                   ("thmc50.o: Client deregistration failed, client not detached.\n");
+               return err;
+       }
+
+       kfree(client->data);
+
+       return 0;
+}
+
+
+/* All registers are word-sized, except for the configuration register.
+   THMC50 uses a high-byte first convention, which is exactly opposite to
+   the usual practice. */
+static int thmc50_read_value(struct i2c_client *client, u8 reg)
+{
+       return i2c_smbus_read_byte_data(client, reg);
+}
+
+/* All registers are word-sized, except for the configuration register.
+   THMC50 uses a high-byte first convention, which is exactly opposite to
+   the usual practice. */
+static int thmc50_write_value(struct i2c_client *client, u8 reg, u16 value)
+{
+       return i2c_smbus_write_byte_data(client, reg, value);
+}
+
+static void thmc50_init_client(struct i2c_client *client)
+{
+       thmc50_write_value(client, THMC50_REG_CONF, 1);
+}
+
+static void thmc50_update_client(struct i2c_client *client)
+{
+       struct thmc50_data *data = client->data;
+
+       down(&data->update_lock);
+
+       if ((jiffies - data->last_updated > HZ + HZ / 2) ||
+           (jiffies < data->last_updated) || !data->valid) {
+
+#ifdef DEBUG
+               printk("Starting thmc50 update\n");
+#endif
+
+               data->temp = thmc50_read_value(client, THMC50_REG_TEMP);
+               data->temp_os =
+                   thmc50_read_value(client, THMC50_REG_TEMP_OS);
+               data->temp_hyst =
+                   thmc50_read_value(client, THMC50_REG_TEMP_HYST);
+               data->remote_temp =
+                   thmc50_read_value(client, THMC50_REG_REMOTE_TEMP);
+               data->remote_temp_os =
+                   thmc50_read_value(client, THMC50_REG_REMOTE_TEMP_OS);
+               data->remote_temp_hyst =
+                   thmc50_read_value(client, THMC50_REG_REMOTE_TEMP_HYST);
+               data->inter = thmc50_read_value(client, THMC50_REG_INTER);
+               data->inter_mask =
+                   thmc50_read_value(client, THMC50_REG_INTER_MASK);
+               data->die_code =
+                   thmc50_read_value(client, THMC50_REG_DIE_CODE);
+               data->analog_out =
+                   thmc50_read_value(client, THMC50_REG_ANALOG_OUT);
+               data->last_updated = jiffies;
+               data->valid = 1;
+       }
+
+       up(&data->update_lock);
+}
+
+
+void thmc50_temp(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct thmc50_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               thmc50_update_client(client);
+               results[0] = TEMP_FROM_REG(data->temp_os);
+               results[1] = TEMP_FROM_REG(data->temp_hyst);
+               results[2] = TEMP_FROM_REG(data->temp);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->temp_os = TEMP_TO_REG(results[0]);
+                       thmc50_write_value(client, THMC50_REG_TEMP_OS,
+                                          data->temp_os);
+               }
+               if (*nrels_mag >= 2) {
+                       data->temp_hyst = TEMP_TO_REG(results[1]);
+                       thmc50_write_value(client, THMC50_REG_TEMP_HYST,
+                                          data->temp_hyst);
+               }
+       }
+}
+
+
+void thmc50_remote_temp(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results)
+{
+       struct thmc50_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               thmc50_update_client(client);
+               results[0] = TEMP_FROM_REG(data->remote_temp_os);
+               results[1] = TEMP_FROM_REG(data->remote_temp_hyst);
+               results[2] = TEMP_FROM_REG(data->remote_temp);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->remote_temp_os = TEMP_TO_REG(results[0]);
+                       thmc50_write_value(client,
+                                          THMC50_REG_REMOTE_TEMP_OS,
+                                          data->remote_temp_os);
+               }
+               if (*nrels_mag >= 2) {
+                       data->remote_temp_hyst = TEMP_TO_REG(results[1]);
+                       thmc50_write_value(client,
+                                          THMC50_REG_REMOTE_TEMP_HYST,
+                                          data->remote_temp_hyst);
+               }
+       }
+}
+
+
+void thmc50_inter(struct i2c_client *client, int operation, int ctl_name,
+                 int *nrels_mag, long *results)
+{
+       struct thmc50_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               thmc50_update_client(client);
+               results[0] = data->inter;
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               printk("thmc50.o: No writes to Interrupt register!\n");
+       }
+}
+
+
+void thmc50_inter_mask(struct i2c_client *client, int operation,
+                      int ctl_name, int *nrels_mag, long *results)
+{
+       struct thmc50_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               thmc50_update_client(client);
+               results[0] = data->inter_mask;
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->inter_mask = results[0];
+                       thmc50_write_value(client, THMC50_REG_INTER_MASK,
+                                          data->inter_mask);
+               }
+       }
+}
+
+
+void thmc50_die_code(struct i2c_client *client, int operation,
+                    int ctl_name, int *nrels_mag, long *results)
+{
+       struct thmc50_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               thmc50_update_client(client);
+               results[0] = data->die_code;
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               printk("thmc50.o: No writes to Die-Code register!\n");
+       }
+}
+
+
+void thmc50_analog_out(struct i2c_client *client, int operation,
+                      int ctl_name, int *nrels_mag, long *results)
+{
+       struct thmc50_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               thmc50_update_client(client);
+               results[0] = data->analog_out;
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->analog_out = results[0];
+                       thmc50_write_value(client, THMC50_REG_ANALOG_OUT,
+                                          data->analog_out);
+               }
+       }
+}
+
+
+
+
+static int __init sm_thmc50_init(void)
+{
+       printk("thmc50.o version %s (%s)\n", LM_VERSION, LM_DATE);
+
+       return i2c_add_driver(&thmc50_driver);
+}
+
+static void __exit sm_thmc50_exit(void)
+{
+       i2c_del_driver(&thmc50_driver);
+}
+
+
+
+MODULE_AUTHOR
+    ("Frodo Looijaard <frodol@dds.nl> and Philip Edelbrock <phil@netroedge.com>");
+MODULE_DESCRIPTION("THMC50 driver");
+
+module_init(sm_thmc50_init);
+module_exit(sm_thmc50_exit);
--- linux-old/drivers/sensors/via686a.c Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/via686a.c     Mon Dec 13 20:18:52 2004
@@ -0,0 +1,849 @@
+/*
+    via686a.c - Part of lm_sensors, Linux kernel modules
+                for hardware monitoring
+                
+    Copyright (c) 1998 - 2002  Frodo Looijaard <frodol@dds.nl>,
+                        Kyösti Mälkki <kmalkki@cc.hut.fi>,
+                       Mark Studebaker <mdsxyz123@yahoo.com>,
+                       and Bob Dougherty <bobd@stanford.edu>
+    (Some conversion-factor data were contributed by Jonathan Teh Soon Yew 
+    <j.teh@iname.com> and Alex van Kaam <darkside@chello.nl>.)
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+    Supports the Via VT82C686A, VT82C686B south bridges.
+    Reports all as a 686A.
+    See doc/chips/via686a for details.
+    Warning - only supports a single device.
+*/
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/pci.h>
+#include <linux/delay.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#include <asm/io.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+
+/* If force_addr is set to anything different from 0, we forcibly enable
+   the device at the given address. */
+static int force_addr = 0;
+MODULE_PARM(force_addr, "i");
+MODULE_PARM_DESC(force_addr,
+                "Initialize the base address of the sensors");
+
+/* Addresses to scan.
+   Note that we can't determine the ISA address until we have initialized
+   our module */
+static unsigned short normal_i2c[] = { SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { SENSORS_I2C_END };
+static unsigned int normal_isa[] = { 0x0000, SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+/* Insmod parameters */
+SENSORS_INSMOD_1(via686a);
+
+/*
+   The Via 686a southbridge has a LM78-like chip integrated on the same IC.
+   This driver is a customized copy of lm78.c
+*/
+
+/* Many VIA686A constants specified below */
+
+/* Length of ISA address segment */
+#define VIA686A_EXTENT 0x80
+#define VIA686A_BASE_REG 0x70
+#define VIA686A_ENABLE_REG 0x74
+
+/* The VIA686A registers */
+/* ins numbered 0-4 */
+#define VIA686A_REG_IN_MAX(nr) (0x2b + ((nr) * 2))
+#define VIA686A_REG_IN_MIN(nr) (0x2c + ((nr) * 2))
+#define VIA686A_REG_IN(nr)     (0x22 + (nr))
+
+/* fans numbered 1-2 */
+#define VIA686A_REG_FAN_MIN(nr) (0x3a + (nr))
+#define VIA686A_REG_FAN(nr)     (0x28 + (nr))
+
+// the following values are as speced by VIA:
+static const u8 regtemp[] = { 0x20, 0x21, 0x1f };
+static const u8 regover[] = { 0x39, 0x3d, 0x1d };
+static const u8 reghyst[] = { 0x3a, 0x3e, 0x1e };
+
+/* temps numbered 1-3 */
+#define VIA686A_REG_TEMP(nr)           (regtemp[(nr) - 1])
+#define VIA686A_REG_TEMP_OVER(nr)      (regover[(nr) - 1])
+#define VIA686A_REG_TEMP_HYST(nr)      (reghyst[(nr) - 1])
+#define VIA686A_REG_TEMP_LOW1  0x4b    // bits 7-6
+#define VIA686A_REG_TEMP_LOW23 0x49    // 2 = bits 5-4, 3 = bits 7-6
+
+#define VIA686A_REG_ALARM1 0x41
+#define VIA686A_REG_ALARM2 0x42
+#define VIA686A_REG_FANDIV 0x47
+#define VIA686A_REG_CONFIG 0x40
+// The following register sets temp interrupt mode (bits 1-0 for temp1, 
+// 3-2 for temp2, 5-4 for temp3).  Modes are:
+//    00 interrupt stays as long as value is out-of-range
+//    01 interrupt is cleared once register is read (default)
+//    10 comparator mode- like 00, but ignores hysteresis
+//    11 same as 00
+#define VIA686A_REG_TEMP_MODE 0x4b
+// We'll just assume that you want to set all 3 simultaneously:
+#define VIA686A_TEMP_MODE_MASK 0x3F
+#define VIA686A_TEMP_MODE_CONTINUOUS (0x00)
+
+/* Conversions. Limit checking is only done on the TO_REG
+   variants. */
+
+/********* VOLTAGE CONVERSIONS (Bob Dougherty) ********/
+// From HWMon.cpp (Copyright 1998-2000 Jonathan Teh Soon Yew):
+// voltagefactor[0]=1.25/2628; (2628/1.25=2102.4)   // Vccp
+// voltagefactor[1]=1.25/2628; (2628/1.25=2102.4)   // +2.5V
+// voltagefactor[2]=1.67/2628; (2628/1.67=1573.7)   // +3.3V
+// voltagefactor[3]=2.6/2628;  (2628/2.60=1010.8)   // +5V
+// voltagefactor[4]=6.3/2628;  (2628/6.30=417.14)   // +12V
+// in[i]=(data[i+2]*25.0+133)*voltagefactor[i];
+// That is:
+// volts = (25*regVal+133)*factor
+// regVal = (volts/factor-133)/25
+// (These conversions were contributed by Jonathan Teh Soon Yew 
+// <j.teh@iname.com>)
+static inline u8 IN_TO_REG(long val, int inNum)
+{
+       /* To avoid floating point, we multiply constants by 10 (100 for +12V).
+          Rounding is done (120500 is actually 133000 - 12500).
+          Remember that val is expressed in 0.01V/bit, which is why we divide
+          by an additional 1000 (10000 for +12V): 100 for val and 10 (100)
+          for the constants. */
+       if (inNum <= 1)
+               return (u8)
+                   SENSORS_LIMIT((val * 21024 - 120500) / 25000, 0, 255);
+       else if (inNum == 2)
+               return (u8)
+                   SENSORS_LIMIT((val * 15737 - 120500) / 25000, 0, 255);
+       else if (inNum == 3)
+               return (u8)
+                   SENSORS_LIMIT((val * 10108 - 120500) / 25000, 0, 255);
+       else
+               return (u8)
+                   SENSORS_LIMIT((val * 41714 - 1205000) / 250000, 0, 255);
+}
+
+static inline long IN_FROM_REG(u8 val, int inNum)
+{
+       /* To avoid floating point, we multiply constants by 10 (100 for +12V).
+          We also multiply them by 100 because we want 0.01V/bit for the
+          output value. Rounding is done. */
+       if (inNum <= 1)
+               return (long) ((25000 * val + 133000 + 21024 / 2) / 21024);
+       else if (inNum == 2)
+               return (long) ((25000 * val + 133000 + 15737 / 2) / 15737);
+       else if (inNum == 3)
+               return (long) ((25000 * val + 133000 + 10108 / 2) / 10108);
+       else
+               return (long) ((250000 * val + 1330000 + 41714 / 2) / 41714);
+}
+
+/********* FAN RPM CONVERSIONS ********/
+// Higher register values = slower fans (the fan's strobe gates a counter).
+// But this chip saturates back at 0, not at 255 like all the other chips.
+// So, 0 means 0 RPM
+static inline u8 FAN_TO_REG(long rpm, int div)
+{
+       if (rpm == 0)
+               return 0;
+       rpm = SENSORS_LIMIT(rpm, 1, 1000000);
+       return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 255);
+}
+
+#define FAN_FROM_REG(val,div) ((val)==0?0:(val)==255?0:1350000/((val)*(div)))
+
+/******** TEMP CONVERSIONS (Bob Dougherty) *********/
+// linear fits from HWMon.cpp (Copyright 1998-2000 Jonathan Teh Soon Yew)
+//      if(temp<169)
+//              return double(temp)*0.427-32.08;
+//      else if(temp>=169 && temp<=202)
+//              return double(temp)*0.582-58.16;
+//      else
+//              return double(temp)*0.924-127.33;
+//
+// A fifth-order polynomial fits the unofficial data (provided by Alex van 
+// Kaam <darkside@chello.nl>) a bit better.  It also give more reasonable 
+// numbers on my machine (ie. they agree with what my BIOS tells me).  
+// Here's the fifth-order fit to the 8-bit data:
+// temp = 1.625093e-10*val^5 - 1.001632e-07*val^4 + 2.457653e-05*val^3 - 
+//        2.967619e-03*val^2 + 2.175144e-01*val - 7.090067e+0.
+//
+// (2000-10-25- RFD: thanks to Uwe Andersen <uandersen@mayah.com> for 
+// finding my typos in this formula!)
+//
+// Alas, none of the elegant function-fit solutions will work because we 
+// aren't allowed to use floating point in the kernel and doing it with 
+// integers doesn't rpovide enough precision.  So we'll do boring old 
+// look-up table stuff.  The unofficial data (see below) have effectively 
+// 7-bit resolution (they are rounded to the nearest degree).  I'm assuming 
+// that the transfer function of the device is monotonic and smooth, so a 
+// smooth function fit to the data will allow us to get better precision.  
+// I used the 5th-order poly fit described above and solved for
+// VIA register values 0-255.  I *10 before rounding, so we get tenth-degree 
+// precision.  (I could have done all 1024 values for our 10-bit readings, 
+// but the function is very linear in the useful range (0-80 deg C), so 
+// we'll just use linear interpolation for 10-bit readings.)  So, tempLUT 
+// is the temp at via register values 0-255:
+static const long tempLUT[] =
+    { -709, -688, -667, -646, -627, -607, -589, -570, -553, -536, -519,
+           -503, -487, -471, -456, -442, -428, -414, -400, -387, -375,
+           -362, -350, -339, -327, -316, -305, -295, -285, -275, -265,
+           -255, -246, -237, -229, -220, -212, -204, -196, -188, -180,
+           -173, -166, -159, -152, -145, -139, -132, -126, -120, -114,
+           -108, -102, -96, -91, -85, -80, -74, -69, -64, -59, -54, -49,
+           -44, -39, -34, -29, -25, -20, -15, -11, -6, -2, 3, 7, 12, 16,
+           20, 25, 29, 33, 37, 42, 46, 50, 54, 59, 63, 67, 71, 75, 79, 84,
+           88, 92, 96, 100, 104, 109, 113, 117, 121, 125, 130, 134, 138,
+           142, 146, 151, 155, 159, 163, 168, 172, 176, 181, 185, 189,
+           193, 198, 202, 206, 211, 215, 219, 224, 228, 232, 237, 241,
+           245, 250, 254, 259, 263, 267, 272, 276, 281, 285, 290, 294,
+           299, 303, 307, 312, 316, 321, 325, 330, 334, 339, 344, 348,
+           353, 357, 362, 366, 371, 376, 380, 385, 390, 395, 399, 404,
+           409, 414, 419, 423, 428, 433, 438, 443, 449, 454, 459, 464,
+           469, 475, 480, 486, 491, 497, 502, 508, 514, 520, 526, 532,
+           538, 544, 551, 557, 564, 571, 578, 584, 592, 599, 606, 614,
+           621, 629, 637, 645, 654, 662, 671, 680, 689, 698, 708, 718,
+           728, 738, 749, 759, 770, 782, 793, 805, 818, 830, 843, 856,
+           870, 883, 898, 912, 927, 943, 958, 975, 991, 1008, 1026, 1044,
+           1062, 1081, 1101, 1121, 1141, 1162, 1184, 1206, 1229, 1252,
+           1276, 1301, 1326, 1352, 1378, 1406, 1434, 1462
+};
+
+/* the original LUT values from Alex van Kaam <darkside@chello.nl> 
+   (for via register values 12-240):
+{-50,-49,-47,-45,-43,-41,-39,-38,-37,-35,-34,-33,-32,-31,
+-30,-29,-28,-27,-26,-25,-24,-24,-23,-22,-21,-20,-20,-19,-18,-17,-17,-16,-15,
+-15,-14,-14,-13,-12,-12,-11,-11,-10,-9,-9,-8,-8,-7,-7,-6,-6,-5,-5,-4,-4,-3,
+-3,-2,-2,-1,-1,0,0,1,1,1,3,3,3,4,4,4,5,5,5,6,6,7,7,8,8,9,9,9,10,10,11,11,12,
+12,12,13,13,13,14,14,15,15,16,16,16,17,17,18,18,19,19,20,20,21,21,21,22,22,
+22,23,23,24,24,25,25,26,26,26,27,27,27,28,28,29,29,30,30,30,31,31,32,32,33,
+33,34,34,35,35,35,36,36,37,37,38,38,39,39,40,40,41,41,42,42,43,43,44,44,45,
+45,46,46,47,48,48,49,49,50,51,51,52,52,53,53,54,55,55,56,57,57,58,59,59,60,
+61,62,62,63,64,65,66,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,83,84,
+85,86,88,89,91,92,94,96,97,99,101,103,105,107,109,110};
+*/
+
+// Here's the reverse LUT.  I got it by doing a 6-th order poly fit (needed
+// an extra term for a good fit to these inverse data!) and then 
+// solving for each temp value from -50 to 110 (the useable range for 
+// this chip).  Here's the fit: 
+// viaRegVal = -1.160370e-10*val^6 +3.193693e-08*val^5 - 1.464447e-06*val^4 
+// - 2.525453e-04*val^3 + 1.424593e-02*val^2 + 2.148941e+00*val +7.275808e+01)
+// Note that n=161:
+static const u8 viaLUT[] =
+    { 12, 12, 13, 14, 14, 15, 16, 16, 17, 18, 18, 19, 20, 20, 21, 22, 23,
+           23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 35, 36, 37, 39, 40,
+           41, 43, 45, 46, 48, 49, 51, 53, 55, 57, 59, 60, 62, 64, 66,
+           69, 71, 73, 75, 77, 79, 82, 84, 86, 88, 91, 93, 95, 98, 100,
+           103, 105, 107, 110, 112, 115, 117, 119, 122, 124, 126, 129,
+           131, 134, 136, 138, 140, 143, 145, 147, 150, 152, 154, 156,
+           158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180,
+           182, 183, 185, 187, 188, 190, 192, 193, 195, 196, 198, 199,
+           200, 202, 203, 205, 206, 207, 208, 209, 210, 211, 212, 213,
+           214, 215, 216, 217, 218, 219, 220, 221, 222, 222, 223, 224,
+           225, 226, 226, 227, 228, 228, 229, 230, 230, 231, 232, 232,
+           233, 233, 234, 235, 235, 236, 236, 237, 237, 238, 238, 239,
+           239, 240
+};
+
+/* Converting temps to (8-bit) hyst and over registers
+   No interpolation here.
+   The +50 is because the temps start at -50 */
+static inline u8 TEMP_TO_REG(long val)
+{
+       return viaLUT[val <= -500 ? 0 : val >= 1100 ? 160 : 
+                     (val < 0 ? val - 5 : val + 5) / 10 + 50];
+}
+
+/* for 8-bit temperature hyst and over registers */
+#define TEMP_FROM_REG(val) (tempLUT[(val)])
+
+/* for 10-bit temperature readings */
+// You might _think_ this is too long to inline, but's it's really only
+// called once...
+static inline long TEMP_FROM_REG10(u16 val)
+{
+       // the temp values are already *10, so we don't need to do that.
+       long temp;
+       u16 eightBits = val >> 2;
+       u16 twoBits = val & 3;
+
+       /* no interpolation for these */
+       if (twoBits == 0 || eightBits == 255)
+               return (long) tempLUT[eightBits];
+
+       /* do some linear interpolation */
+       temp = (4 - twoBits) * tempLUT[eightBits]
+            + twoBits * tempLUT[eightBits + 1];
+       /* achieve rounding */
+       return (temp < 0 ? temp - 2 : temp + 2) / 4;
+}
+
+#define ALARMS_FROM_REG(val) (val)
+
+#define DIV_FROM_REG(val) (1 << (val))
+#define DIV_TO_REG(val) ((val)==8?3:(val)==4?2:(val)==1?0:1)
+
+/* For the VIA686A, we need to keep some data in memory.
+   The structure is dynamically allocated, at the same time when a new
+   via686a client is allocated. */
+struct via686a_data {
+       struct i2c_client client;
+       struct semaphore lock;
+       int sysctl_id;
+
+       struct semaphore update_lock;
+       char valid;             /* !=0 if following fields are valid */
+       unsigned long last_updated;     /* In jiffies */
+
+       u8 in[5];               /* Register value */
+       u8 in_max[5];           /* Register value */
+       u8 in_min[5];           /* Register value */
+       u8 fan[2];              /* Register value */
+       u8 fan_min[2];          /* Register value */
+       u16 temp[3];            /* Register value 10 bit */
+       u8 temp_over[3];        /* Register value */
+       u8 temp_hyst[3];        /* Register value */
+       u8 fan_div[2];          /* Register encoding, shifted right */
+       u16 alarms;             /* Register encoding, combined */
+};
+
+static struct pci_dev *s_bridge;       /* pointer to the (only) via686a */
+
+static int via686a_attach_adapter(struct i2c_adapter *adapter);
+static int via686a_detect(struct i2c_adapter *adapter, int address,
+                         unsigned short flags, int kind);
+static int via686a_detach_client(struct i2c_client *client);
+
+static int via686a_read_value(struct i2c_client *client, u8 register);
+static void via686a_write_value(struct i2c_client *client, u8 register,
+                               u8 value);
+static void via686a_update_client(struct i2c_client *client);
+static void via686a_init_client(struct i2c_client *client);
+
+
+static void via686a_in(struct i2c_client *client, int operation,
+                      int ctl_name, int *nrels_mag, long *results);
+static void via686a_fan(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void via686a_temp(struct i2c_client *client, int operation,
+                        int ctl_name, int *nrels_mag, long *results);
+static void via686a_alarms(struct i2c_client *client, int operation,
+                          int ctl_name, int *nrels_mag, long *results);
+static void via686a_fan_div(struct i2c_client *client, int operation,
+                           int ctl_name, int *nrels_mag, long *results);
+
+static int via686a_id = 0;
+
+/* The driver. I choose to use type i2c_driver, as at is identical to both
+   smbus_driver and isa_driver, and clients could be of either kind */
+static struct i2c_driver via686a_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "VIA 686A",
+       .id             = I2C_DRIVERID_VIA686A,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = via686a_attach_adapter,
+       .detach_client  = via686a_detach_client,
+};
+
+
+
+/* The /proc/sys entries */
+
+/* -- SENSORS SYSCTL START -- */
+#define VIA686A_SYSCTL_IN0 1000
+#define VIA686A_SYSCTL_IN1 1001
+#define VIA686A_SYSCTL_IN2 1002
+#define VIA686A_SYSCTL_IN3 1003
+#define VIA686A_SYSCTL_IN4 1004
+#define VIA686A_SYSCTL_FAN1 1101
+#define VIA686A_SYSCTL_FAN2 1102
+#define VIA686A_SYSCTL_TEMP 1200
+#define VIA686A_SYSCTL_TEMP2 1201
+#define VIA686A_SYSCTL_TEMP3 1202
+#define VIA686A_SYSCTL_FAN_DIV 2000
+#define VIA686A_SYSCTL_ALARMS 2001
+
+#define VIA686A_ALARM_IN0 0x01
+#define VIA686A_ALARM_IN1 0x02
+#define VIA686A_ALARM_IN2 0x04
+#define VIA686A_ALARM_IN3 0x08
+#define VIA686A_ALARM_TEMP 0x10
+#define VIA686A_ALARM_FAN1 0x40
+#define VIA686A_ALARM_FAN2 0x80
+#define VIA686A_ALARM_IN4 0x100
+#define VIA686A_ALARM_TEMP2 0x800
+#define VIA686A_ALARM_CHAS 0x1000
+#define VIA686A_ALARM_TEMP3 0x8000
+
+/* -- SENSORS SYSCTL END -- */
+
+/* These files are created for each detected VIA686A. This is just a template;
+   though at first sight, you might think we could use a statically
+   allocated list, we need some way to get back to the parent - which
+   is done through one of the 'extra' fields which are initialized 
+   when a new copy is allocated. */
+static ctl_table via686a_dir_table_template[] = {
+       {VIA686A_SYSCTL_IN0, "in0", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &via686a_in},
+       {VIA686A_SYSCTL_IN1, "in1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &via686a_in},
+       {VIA686A_SYSCTL_IN2, "in2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &via686a_in},
+       {VIA686A_SYSCTL_IN3, "in3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &via686a_in},
+       {VIA686A_SYSCTL_IN4, "in4", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &via686a_in},
+       {VIA686A_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &via686a_fan},
+       {VIA686A_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &via686a_fan},
+       {VIA686A_SYSCTL_TEMP, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &via686a_temp},
+       {VIA686A_SYSCTL_TEMP2, "temp2", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &via686a_temp},
+       {VIA686A_SYSCTL_TEMP3, "temp3", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &via686a_temp},
+       {VIA686A_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &via686a_fan_div},
+       {VIA686A_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &via686a_alarms},
+       {0}
+};
+
+static inline int via686a_read_value(struct i2c_client *client, u8 reg)
+{
+       return (inb_p(client->addr + reg));
+}
+
+static inline void via686a_write_value(struct i2c_client *client, u8 reg,
+                                      u8 value)
+{
+       outb_p(value, client->addr + reg);
+}
+
+/* This is called when the module is loaded */
+static int via686a_attach_adapter(struct i2c_adapter *adapter)
+{
+       return i2c_detect(adapter, &addr_data, via686a_detect);
+}
+
+int via686a_detect(struct i2c_adapter *adapter, int address,
+                  unsigned short flags, int kind)
+{
+       int i;
+       struct i2c_client *new_client;
+       struct via686a_data *data;
+       int err = 0;
+       const char *type_name = "via686a";
+       u16 val;
+
+       /* Make sure we are probing the ISA bus!!  */
+       if (!i2c_is_isa_adapter(adapter)) {
+               printk
+               ("via686a.o: via686a_detect called for an I2C bus adapter?!?\n");
+               return 0;
+       }
+
+       /* 8231 requires multiple of 256, we enforce that on 686 as well */
+       if(force_addr)
+               address = force_addr & 0xFF00;
+       if (check_region(address, VIA686A_EXTENT)) {
+               printk("via686a.o: region 0x%x already in use!\n",
+                      address);
+               return -ENODEV;
+       }
+
+       if(force_addr) {
+               printk("via686a.o: forcing ISA address 0x%04X\n", address);
+               if (PCIBIOS_SUCCESSFUL !=
+                   pci_write_config_word(s_bridge, VIA686A_BASE_REG, address))
+                       return -ENODEV;
+       }
+       if (PCIBIOS_SUCCESSFUL !=
+           pci_read_config_word(s_bridge, VIA686A_ENABLE_REG, &val))
+               return -ENODEV;
+       if (!(val & 0x0001)) {
+               printk("via686a.o: enabling sensors\n");
+               if (PCIBIOS_SUCCESSFUL !=
+                   pci_write_config_word(s_bridge, VIA686A_ENABLE_REG,
+                                     val | 0x0001))
+                       return -ENODEV;
+       }
+
+       if (!(data = kmalloc(sizeof(struct via686a_data), GFP_KERNEL))) {
+               err = -ENOMEM;
+               goto ERROR0;
+       }
+
+       new_client = &data->client;
+       new_client->addr = address;
+       init_MUTEX(&data->lock);
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &via686a_driver;
+       new_client->flags = 0;
+
+       /* Reserve the ISA region */
+       request_region(address, VIA686A_EXTENT, "via686a-sensors");
+
+       /* Fill in the remaining client fields and put into the global list */
+       strcpy(new_client->name, "Via 686A Integrated Sensors");
+
+       new_client->id = via686a_id++;
+       data->valid = 0;
+       init_MUTEX(&data->update_lock);
+
+       /* Tell the I2C layer a new client has arrived */
+       if ((err = i2c_attach_client(new_client)))
+               goto ERROR3;
+
+       /* Register a new directory entry with module sensors */
+       if ((i = i2c_register_entry((struct i2c_client *) new_client,
+                                       type_name,
+                                       via686a_dir_table_template)) < 0) {
+               err = i;
+               goto ERROR4;
+       }
+       data->sysctl_id = i;
+
+       /* Initialize the VIA686A chip */
+       via686a_init_client(new_client);
+       return 0;
+
+      ERROR4:
+       i2c_detach_client(new_client);
+      ERROR3:
+       release_region(address, VIA686A_EXTENT);
+       kfree(data);
+      ERROR0:
+       return err;
+}
+
+static int via686a_detach_client(struct i2c_client *client)
+{
+       int err;
+
+       i2c_deregister_entry(((struct via686a_data *) 
+                                 (client->data))->sysctl_id);
+
+       if ((err = i2c_detach_client(client))) {
+               printk
+               ("via686a.o: Client deregistration failed, client not detached.\n");
+               return err;
+       }
+
+       release_region(client->addr, VIA686A_EXTENT);
+       kfree(client->data);
+
+       return 0;
+}
+
+/* Called when we have found a new VIA686A. */
+static void via686a_init_client(struct i2c_client *client)
+{
+       u8 reg;
+
+       /* Start monitoring */
+       reg = via686a_read_value(client, VIA686A_REG_CONFIG);
+       via686a_write_value(client, VIA686A_REG_CONFIG, (reg|0x01)&0x7F);
+
+       /* Configure temp interrupt mode for continuous-interrupt operation */
+       via686a_write_value(client, VIA686A_REG_TEMP_MODE, 
+                           via686a_read_value(client, VIA686A_REG_TEMP_MODE) &
+                           !(VIA686A_TEMP_MODE_MASK | VIA686A_TEMP_MODE_CONTINUOUS));
+}
+
+static void via686a_update_client(struct i2c_client *client)
+{
+       struct via686a_data *data = client->data;
+       int i;
+
+       down(&data->update_lock);
+
+       if (time_after(jiffies - data->last_updated, HZ + HZ / 2) ||
+           time_before(jiffies, data->last_updated) || !data->valid) {
+
+               for (i = 0; i <= 4; i++) {
+                       data->in[i] =
+                           via686a_read_value(client, VIA686A_REG_IN(i));
+                       data->in_min[i] = via686a_read_value(client,
+                                                            VIA686A_REG_IN_MIN
+                                                            (i));
+                       data->in_max[i] =
+                           via686a_read_value(client, VIA686A_REG_IN_MAX(i));
+               }
+               for (i = 1; i <= 2; i++) {
+                       data->fan[i - 1] =
+                           via686a_read_value(client, VIA686A_REG_FAN(i));
+                       data->fan_min[i - 1] = via686a_read_value(client,
+                                                    VIA686A_REG_FAN_MIN(i));
+               }
+               for (i = 1; i <= 3; i++) {
+                       data->temp[i - 1] = via686a_read_value(client,
+                                                VIA686A_REG_TEMP(i)) << 2;
+                       data->temp_over[i - 1] =
+                           via686a_read_value(client,
+                                              VIA686A_REG_TEMP_OVER(i));
+                       data->temp_hyst[i - 1] =
+                           via686a_read_value(client,
+                                              VIA686A_REG_TEMP_HYST(i));
+               }
+               /* add in lower 2 bits 
+                  temp1 uses bits 7-6 of VIA686A_REG_TEMP_LOW1
+                  temp2 uses bits 5-4 of VIA686A_REG_TEMP_LOW23
+                  temp3 uses bits 7-6 of VIA686A_REG_TEMP_LOW23
+                */
+               data->temp[0] |= (via686a_read_value(client,
+                                                    VIA686A_REG_TEMP_LOW1)
+                                 & 0xc0) >> 6;
+               data->temp[1] |=
+                   (via686a_read_value(client, VIA686A_REG_TEMP_LOW23) &
+                    0x30) >> 4;
+               data->temp[2] |=
+                   (via686a_read_value(client, VIA686A_REG_TEMP_LOW23) &
+                    0xc0) >> 6;
+
+               i = via686a_read_value(client, VIA686A_REG_FANDIV);
+               data->fan_div[0] = (i >> 4) & 0x03;
+               data->fan_div[1] = i >> 6;
+               data->alarms =
+                   via686a_read_value(client,
+                                      VIA686A_REG_ALARM1) |
+                   (via686a_read_value(client, VIA686A_REG_ALARM2) << 8);
+               data->last_updated = jiffies;
+               data->valid = 1;
+       }
+
+       up(&data->update_lock);
+}
+
+
+/* The next few functions are the call-back functions of the /proc/sys and
+   sysctl files. Which function is used is defined in the ctl_table in
+   the extra1 field.
+   Each function must return the magnitude (power of 10 to divide the date
+   with) if it is called with operation==SENSORS_PROC_REAL_INFO. It must
+   put a maximum of *nrels elements in results reflecting the data of this
+   file, and set *nrels to the number it actually put in it, if operation==
+   SENSORS_PROC_REAL_READ. Finally, it must get upto *nrels elements from
+   results and write them to the chip, if operations==SENSORS_PROC_REAL_WRITE.
+   Note that on SENSORS_PROC_REAL_READ, I do not check whether results is
+   large enough (by checking the incoming value of *nrels). This is not very
+   good practice, but as long as you put less than about 5 values in results,
+   you can assume it is large enough. */
+static void via686a_in(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       struct via686a_data *data = client->data;
+       int nr = ctl_name - VIA686A_SYSCTL_IN0;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 2;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               via686a_update_client(client);
+               results[0] = IN_FROM_REG(data->in_min[nr], nr);
+               results[1] = IN_FROM_REG(data->in_max[nr], nr);
+               results[2] = IN_FROM_REG(data->in[nr], nr);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->in_min[nr] = IN_TO_REG(results[0], nr);
+                       via686a_write_value(client, VIA686A_REG_IN_MIN(nr),
+                                           data->in_min[nr]);
+               }
+               if (*nrels_mag >= 2) {
+                       data->in_max[nr] = IN_TO_REG(results[1], nr);
+                       via686a_write_value(client, VIA686A_REG_IN_MAX(nr),
+                                           data->in_max[nr]);
+               }
+       }
+}
+
+void via686a_fan(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct via686a_data *data = client->data;
+       int nr = ctl_name - VIA686A_SYSCTL_FAN1 + 1;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               via686a_update_client(client);
+               results[0] = FAN_FROM_REG(data->fan_min[nr - 1],
+                                         DIV_FROM_REG(data->fan_div
+                                                      [nr - 1]));
+               results[1] = FAN_FROM_REG(data->fan[nr - 1],
+                                DIV_FROM_REG(data->fan_div[nr - 1]));
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->fan_min[nr - 1] = FAN_TO_REG(results[0], 
+                                                          DIV_FROM_REG(data->
+                                                             fan_div[nr -1]));
+                       via686a_write_value(client,
+                                           VIA686A_REG_FAN_MIN(nr),
+                                           data->fan_min[nr - 1]);
+               }
+       }
+}
+
+void via686a_temp(struct i2c_client *client, int operation, int ctl_name,
+                 int *nrels_mag, long *results)
+{
+       struct via686a_data *data = client->data;
+       int nr = ctl_name - VIA686A_SYSCTL_TEMP;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               via686a_update_client(client);
+               results[0] = TEMP_FROM_REG(data->temp_over[nr]);
+               results[1] = TEMP_FROM_REG(data->temp_hyst[nr]);
+               results[2] = TEMP_FROM_REG10(data->temp[nr]);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->temp_over[nr] = TEMP_TO_REG(results[0]);
+                       via686a_write_value(client,
+                                           VIA686A_REG_TEMP_OVER(nr + 1),
+                                           data->temp_over[nr]);
+               }
+               if (*nrels_mag >= 2) {
+                       data->temp_hyst[nr] = TEMP_TO_REG(results[1]);
+                       via686a_write_value(client,
+                                           VIA686A_REG_TEMP_HYST(nr + 1),
+                                           data->temp_hyst[nr]);
+               }
+       }
+}
+
+void via686a_alarms(struct i2c_client *client, int operation, int ctl_name,
+                   int *nrels_mag, long *results)
+{
+       struct via686a_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               via686a_update_client(client);
+               results[0] = ALARMS_FROM_REG(data->alarms);
+               *nrels_mag = 1;
+       }
+}
+
+void via686a_fan_div(struct i2c_client *client, int operation,
+                    int ctl_name, int *nrels_mag, long *results)
+{
+       struct via686a_data *data = client->data;
+       int old;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               via686a_update_client(client);
+               results[0] = DIV_FROM_REG(data->fan_div[0]);
+               results[1] = DIV_FROM_REG(data->fan_div[1]);
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               old = via686a_read_value(client, VIA686A_REG_FANDIV);
+               if (*nrels_mag >= 2) {
+                       data->fan_div[1] = DIV_TO_REG(results[1]);
+                       old = (old & 0x3f) | (data->fan_div[1] << 6);
+               }
+               if (*nrels_mag >= 1) {
+                       data->fan_div[0] = DIV_TO_REG(results[0]);
+                       old = (old & 0xcf) | (data->fan_div[0] << 4);
+                       via686a_write_value(client, VIA686A_REG_FANDIV,
+                                           old);
+               }
+       }
+}
+
+
+static struct pci_device_id via686a_pci_ids[] __devinitdata = {
+       {PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C686_4, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
+       { 0, }
+};
+
+static int __devinit via686a_pci_probe(struct pci_dev *dev,
+                                      const struct pci_device_id *id)
+{
+       u16 val;
+       int addr = 0;
+
+       if (PCIBIOS_SUCCESSFUL !=
+           pci_read_config_word(dev, VIA686A_BASE_REG, &val))
+               return -ENODEV;
+
+       addr = val & ~(VIA686A_EXTENT - 1);
+       if (addr == 0 && force_addr == 0) {
+               printk("via686a.o: base address not set - upgrade BIOS or use force_addr=0xaddr\n");
+               return -ENODEV;
+       }
+       if (force_addr)
+               addr = force_addr;      /* so detect will get called */
+
+       if (!addr) {
+               printk("via686a.o: No Via 686A sensors found.\n");
+               return -ENODEV;
+       }
+       normal_isa[0] = addr;
+       s_bridge = dev;
+       return i2c_add_driver(&via686a_driver);
+}
+
+static void __devexit via686a_pci_remove(struct pci_dev *dev)
+{
+       i2c_del_driver(&via686a_driver);
+}
+
+static struct pci_driver via686a_pci_driver = {
+       .name           = "via686a",
+       .id_table       = via686a_pci_ids,
+       .probe          = via686a_pci_probe,
+       .remove         = __devexit_p(via686a_pci_remove),
+};
+
+static int __init sm_via686a_init(void)
+{
+       printk("via686a.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       return pci_module_init(&via686a_pci_driver);
+}
+
+static void __exit sm_via686a_exit(void)
+{
+       pci_unregister_driver(&via686a_pci_driver);
+}
+
+MODULE_AUTHOR("Kyösti Mälkki <kmalkki@cc.hut.fi>, "
+              "Mark Studebaker <mdsxyz123@yahoo.com> "
+             "and Bob Dougherty <bobd@stanford.edu>");
+MODULE_DESCRIPTION("VIA 686A Sensor device");
+MODULE_LICENSE("GPL");
+
+module_init(sm_via686a_init);
+module_exit(sm_via686a_exit);
--- linux-old/drivers/sensors/vt1211.c  Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/vt1211.c      Mon Dec 13 20:18:53 2004
@@ -0,0 +1,823 @@
+/*
+    vt1211.c - Part of lm_sensors, Linux kernel modules
+                for hardware monitoring
+                
+    Copyright (c) 2002 Mark D. Studebaker <mdsxyz123@yahoo.com>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/* Supports VIA VT1211 Super I/O sensors via ISA (LPC) accesses only. */
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/ioport.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#include <asm/io.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+#include <linux/sensors_vid.h>
+
+static int force_addr = 0;
+MODULE_PARM(force_addr, "i");
+MODULE_PARM_DESC(force_addr,
+                "Initialize the base address of the sensors");
+
+static unsigned short normal_i2c[] = { SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { SENSORS_I2C_END };
+static unsigned int normal_isa[] = { 0x0000, SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+SENSORS_INSMOD_1(vt1211);
+
+/* modified from kernel/include/traps.c */
+#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    0x0b    /* The device with the hardware monitor */
+#define        DEVID   0x20    /* Register: Device ID */
+
+static inline void
+superio_outb(int reg, int val)
+{
+       outb(reg, REG);
+       outb(val, VAL);
+}
+
+static inline int
+superio_inb(int reg)
+{
+       outb(reg, REG);
+       return inb(VAL);
+}
+
+static inline void
+superio_select(void)
+{
+       outb(DEV, REG);
+       outb(PME, VAL);
+}
+
+static inline void
+superio_enter(void)
+{
+       outb(0x87, REG);
+       outb(0x87, REG);
+}
+
+static inline void
+superio_exit(void)
+{
+       outb(0xAA, REG);
+}
+
+#define VT1211_DEVID 0x3c
+#define VT1211_ACT_REG 0x30
+#define VT1211_BASE_REG 0x60
+
+#define VT1211_EXTENT 0x80
+
+/* pwm numbered 1-2 */
+#define VT1211_REG_PWM(nr) (0x5f + (nr))
+#define VT1211_REG_PWM_CTL 0x51
+
+/* The VT1211 registers */
+/* We define the sensors as follows. Somewhat convoluted to minimize
+   changes from via686a.
+       Sensor          Voltage Mode    Temp Mode
+       --------        ------------    ---------
+       Reading 1                       temp3
+       Reading 3                       temp1   not in vt1211
+       UCH1/Reading2   in0             temp2
+       UCH2            in1             temp4
+       UCH3            in2             temp5
+       UCH4            in3             temp6
+       UCH5            in4             temp7
+       3.3V            in5
+       -12V            in6                     not in vt1211
+*/
+
+/* ins numbered 0-6 */
+#define VT1211_REG_IN_MAX(nr) ((nr)==0 ? 0x3d : 0x29 + ((nr) * 2))
+#define VT1211_REG_IN_MIN(nr) ((nr)==0 ? 0x3e : 0x2a + ((nr) * 2))
+#define VT1211_REG_IN(nr)     (0x21 + (nr))
+
+/* fans numbered 1-2 */
+#define VT1211_REG_FAN_MIN(nr) (0x3a + (nr))
+#define VT1211_REG_FAN(nr)     (0x28 + (nr))
+
+static const u8 regtemp[] = { 0x20, 0x21, 0x1f, 0x22, 0x23, 0x24, 0x25 };
+static const u8 regover[] = { 0x39, 0x3d, 0x1d, 0x2b, 0x2d, 0x2f, 0x31 };
+static const u8 reghyst[] = { 0x3a, 0x3e, 0x1e, 0x2c, 0x2e, 0x30, 0x32 };
+
+/* temps numbered 1-7 */
+#define VT1211_REG_TEMP(nr)            (regtemp[(nr) - 1])
+#define VT1211_REG_TEMP_OVER(nr)       (regover[(nr) - 1])
+#define VT1211_REG_TEMP_HYST(nr)       (reghyst[(nr) - 1])
+#define VT1211_REG_TEMP_LOW3   0x4b    /* bits 7-6 */
+#define VT1211_REG_TEMP_LOW2   0x49    /* bits 5-4 */
+#define VT1211_REG_TEMP_LOW47  0x4d
+
+#define VT1211_REG_CONFIG 0x40
+#define VT1211_REG_ALARM1 0x41
+#define VT1211_REG_ALARM2 0x42
+#define VT1211_REG_VID    0x45
+#define VT1211_REG_FANDIV 0x47
+#define VT1211_REG_UCH_CONFIG 0x4a
+#define VT1211_REG_TEMP1_CONFIG 0x4b
+#define VT1211_REG_TEMP2_CONFIG 0x4c
+
+/* temps 1-7; voltages 0-6 */
+#define ISTEMP(i, ch_config) ((i) == 1 ? 1 : \
+                             (i) == 3 ? 1 : \
+                             (i) == 2 ? ((ch_config) >> 1) & 0x01 : \
+                                        ((ch_config) >> ((i)-1)) & 0x01)
+#define ISVOLT(i, ch_config) ((i) > 4 ? 1 : !(((ch_config) >> ((i)+2)) & 0x01))
+
+#define DIV_FROM_REG(val) (1 << (val))
+#define DIV_TO_REG(val) ((val)==8?3:(val)==4?2:(val)==1?0:1)
+#define PWM_FROM_REG(val) (val)
+#define PWM_TO_REG(val) SENSORS_LIMIT((val), 0, 255)
+
+#define TEMP_FROM_REG(val) ((val)*10)
+#define TEMP_FROM_REG10(val) (((val)*10)/4)
+#define TEMP_TO_REG(val) (SENSORS_LIMIT(((val)<0?(((val)-5)/10):\
+                                                 ((val)+5)/10),0,255))
+#define IN_FROM_REG(val) /*(((val)*10+5)/10)*/ (val)
+#define IN_TO_REG(val)  (SENSORS_LIMIT((((val) * 10 + 5)/10),0,255))
+
+
+/********* FAN RPM CONVERSIONS ********/
+/* But this chip saturates back at 0, not at 255 like all the other chips.
+   So, 0 means 0 RPM */
+static inline u8 FAN_TO_REG(long rpm, int div)
+{
+       if (rpm == 0)
+               return 0;
+       rpm = SENSORS_LIMIT(rpm, 1, 1000000);
+       return SENSORS_LIMIT((1310720 + rpm * div / 2) / (rpm * div), 1, 255);
+}
+
+#define MIN_TO_REG(a,b) FAN_TO_REG(a,b)
+#define FAN_FROM_REG(val,div) ((val)==0?0:(val)==255?0:1310720/((val)*(div)))
+
+struct vt1211_data {
+       struct i2c_client client;
+       struct semaphore lock;
+       int sysctl_id;
+
+       struct semaphore update_lock;
+       char valid;             /* !=0 if following fields are valid */
+       unsigned long last_updated;     /* In jiffies */
+
+       u8 in[7];               /* Register value */
+       u8 in_max[7];           /* Register value */
+       u8 in_min[7];           /* Register value */
+       u16 temp[7];            /* Register value 10 bit */
+       u8 temp_over[7];        /* Register value */
+       u8 temp_hyst[7];        /* Register value */
+       u8 fan[2];              /* Register value */
+       u8 fan_min[2];          /* Register value */
+       u8 fan_div[2];          /* Register encoding, shifted right */
+       u16 alarms;             /* Register encoding */
+       u8 pwm[2];              /* Register value */
+       u8 pwm_ctl;             /* Register value */
+       u8 vid;                 /* Register encoding */
+       u8 vrm;
+       u8 uch_config;
+};
+
+static int vt1211_attach_adapter(struct i2c_adapter *adapter);
+static int vt1211_detect(struct i2c_adapter *adapter, int address,
+                         unsigned short flags, int kind);
+static int vt1211_detach_client(struct i2c_client *client);
+
+static inline int vt_rdval(struct i2c_client *client, u8 register);
+static inline void vt1211_write_value(struct i2c_client *client, u8 register,
+                              u8 value);
+static void vt1211_update_client(struct i2c_client *client);
+static void vt1211_init_client(struct i2c_client *client);
+static int vt1211_find(int *address);
+
+
+static void vt1211_fan(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void vt1211_alarms(struct i2c_client *client, int operation,
+                          int ctl_name, int *nrels_mag, long *results);
+static void vt1211_fan_div(struct i2c_client *client, int operation,
+                           int ctl_name, int *nrels_mag, long *results);
+static void vt1211_in(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void vt1211_pwm(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void vt1211_vid(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void vt1211_vrm(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void vt1211_uch(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void vt1211_temp(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+
+static int vt1211_id = 0;
+
+static struct i2c_driver vt1211_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "VT1211 sensors driver",
+       .id             = I2C_DRIVERID_VT1211,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = vt1211_attach_adapter,
+       .detach_client  = vt1211_detach_client,
+};
+
+/* -- SENSORS SYSCTL START -- */
+#define VT1211_SYSCTL_IN0 1000
+#define VT1211_SYSCTL_IN1 1001
+#define VT1211_SYSCTL_IN2 1002
+#define VT1211_SYSCTL_IN3 1003
+#define VT1211_SYSCTL_IN4 1004
+#define VT1211_SYSCTL_IN5 1005
+#define VT1211_SYSCTL_IN6 1006
+#define VT1211_SYSCTL_FAN1 1101
+#define VT1211_SYSCTL_FAN2 1102
+#define VT1211_SYSCTL_TEMP 1200
+#define VT1211_SYSCTL_TEMP2 1201
+#define VT1211_SYSCTL_TEMP3 1202
+#define VT1211_SYSCTL_TEMP4 1203
+#define VT1211_SYSCTL_TEMP5 1204
+#define VT1211_SYSCTL_TEMP6 1205
+#define VT1211_SYSCTL_TEMP7 1206
+#define VT1211_SYSCTL_VID      1300
+#define VT1211_SYSCTL_PWM1     1401
+#define VT1211_SYSCTL_PWM2     1402
+#define VT1211_SYSCTL_VRM      1600
+#define VT1211_SYSCTL_UCH      1700
+#define VT1211_SYSCTL_FAN_DIV 2000
+#define VT1211_SYSCTL_ALARMS 2001
+
+#define VT1211_ALARM_IN1 0x01
+#define VT1211_ALARM_IN2 0x02
+#define VT1211_ALARM_IN5 0x04
+#define VT1211_ALARM_IN3 0x08
+#define VT1211_ALARM_TEMP 0x10
+#define VT1211_ALARM_FAN1 0x40
+#define VT1211_ALARM_FAN2 0x80
+#define VT1211_ALARM_IN4 0x100
+#define VT1211_ALARM_IN6 0x200
+#define VT1211_ALARM_TEMP2 0x800
+#define VT1211_ALARM_CHAS 0x1000
+#define VT1211_ALARM_TEMP3 0x8000
+/* duplicates */
+#define VT1211_ALARM_IN0 VT1211_ALARM_TEMP
+#define VT1211_ALARM_TEMP4 VT1211_ALARM_IN1
+#define VT1211_ALARM_TEMP5 VT1211_ALARM_IN2
+#define VT1211_ALARM_TEMP6 VT1211_ALARM_IN3
+#define VT1211_ALARM_TEMP7 VT1211_ALARM_IN4
+
+/* -- SENSORS SYSCTL END -- */
+
+static ctl_table vt1211_dir_table_template[] = {
+       {VT1211_SYSCTL_IN0, "in0", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &vt1211_in},
+       {VT1211_SYSCTL_IN1, "in1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &vt1211_in},
+       {VT1211_SYSCTL_IN2, "in2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &vt1211_in},
+       {VT1211_SYSCTL_IN3, "in3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &vt1211_in},
+       {VT1211_SYSCTL_IN4, "in4", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &vt1211_in},
+       {VT1211_SYSCTL_IN5, "in5", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &vt1211_in},
+/*
+    datasheet says these are reserved
+       {VT1211_SYSCTL_IN6, "in6", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &vt1211_in},
+       {VT1211_SYSCTL_TEMP, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &vt1211_temp},
+*/
+       {VT1211_SYSCTL_TEMP2, "temp2", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &vt1211_temp},
+       {VT1211_SYSCTL_TEMP3, "temp3", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &vt1211_temp},
+       {VT1211_SYSCTL_TEMP4, "temp4", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &vt1211_temp},
+       {VT1211_SYSCTL_TEMP5, "temp5", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &vt1211_temp},
+       {VT1211_SYSCTL_TEMP6, "temp6", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &vt1211_temp},
+       {VT1211_SYSCTL_TEMP7, "temp7", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &vt1211_temp},
+       {VT1211_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &vt1211_fan},
+       {VT1211_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &vt1211_fan},
+       {VT1211_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &vt1211_fan_div},
+       {VT1211_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &vt1211_alarms},
+       {VT1211_SYSCTL_PWM1, "pwm1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &vt1211_pwm},
+       {VT1211_SYSCTL_PWM2, "pwm2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &vt1211_pwm},
+       {VT1211_SYSCTL_VID, "vid", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &vt1211_vid},
+       {VT1211_SYSCTL_VRM, "vrm", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &vt1211_vrm},
+       {VT1211_SYSCTL_UCH, "uch_config", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &vt1211_uch},
+       {0}
+};
+
+static int vt1211_attach_adapter(struct i2c_adapter *adapter)
+{
+       return i2c_detect(adapter, &addr_data, vt1211_detect);
+}
+
+static int vt1211_find(int *address)
+{
+       u16 val;
+
+       superio_enter();
+       val= superio_inb(DEVID);
+       if(VT1211_DEVID != val) {
+               superio_exit();
+               return -ENODEV;
+       }
+
+       superio_select();
+       val = (superio_inb(VT1211_BASE_REG) << 8) |
+              superio_inb(VT1211_BASE_REG + 1);
+       *address = val & ~(VT1211_EXTENT - 1);
+       if (*address == 0 && force_addr == 0) {
+               printk("vt1211.o: base address not set - use force_addr=0xaddr\n");
+               superio_exit();
+               return -ENODEV;
+       }
+       if (force_addr)
+               *address = force_addr;  /* so detect will get called */
+
+       superio_exit();
+       return 0;
+}
+
+int vt1211_detect(struct i2c_adapter *adapter, int address,
+                  unsigned short flags, int kind)
+{
+       int i;
+       struct i2c_client *new_client;
+       struct vt1211_data *data;
+       int err = 0;
+       u8 val;
+       const char *type_name = "vt1211";
+       const char *client_name = "VT1211 chip";
+
+       if (!i2c_is_isa_adapter(adapter)) {
+               return 0;
+       }
+
+       if(force_addr)
+               address = force_addr & ~(VT1211_EXTENT - 1);
+       if (check_region(address, VT1211_EXTENT)) {
+               printk("vt1211.o: region 0x%x already in use!\n", address);
+               return -ENODEV;
+       }
+       if(force_addr) {
+               printk("vt1211.o: forcing ISA address 0x%04X\n", address);
+               superio_enter();
+               superio_select();
+               superio_outb(VT1211_BASE_REG, address >> 8);
+               superio_outb(VT1211_BASE_REG+1, address & 0xff);
+               superio_exit();
+       }
+
+       superio_enter();
+       superio_select();
+       if((val = 0x01 & superio_inb(VT1211_ACT_REG)) == 0)
+               superio_outb(VT1211_ACT_REG, 1);
+       superio_exit();
+
+       if (!(data = kmalloc(sizeof(struct vt1211_data), GFP_KERNEL))) {
+               return -ENOMEM;
+       }
+
+       new_client = &data->client;
+       new_client->addr = address;
+       init_MUTEX(&data->lock);
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &vt1211_driver;
+       new_client->flags = 0;
+
+       request_region(address, VT1211_EXTENT, "vt1211-sensors");
+       strcpy(new_client->name, client_name);
+
+       new_client->id = vt1211_id++;
+       data->valid = 0;
+       init_MUTEX(&data->update_lock);
+
+       if ((err = i2c_attach_client(new_client)))
+               goto ERROR3;
+
+       if ((i = i2c_register_entry((struct i2c_client *) new_client,
+                                       type_name,
+                                       vt1211_dir_table_template)) < 0) {
+               err = i;
+               goto ERROR4;
+       }
+       data->sysctl_id = i;
+
+       vt1211_init_client(new_client);
+       return 0;
+
+      ERROR4:
+       i2c_detach_client(new_client);
+      ERROR3:
+       release_region(address, VT1211_EXTENT);
+       kfree(data);
+       return err;
+}
+
+static int vt1211_detach_client(struct i2c_client *client)
+{
+       int err;
+
+       i2c_deregister_entry(((struct vt1211_data *) (client->data))->
+                                sysctl_id);
+
+       if ((err = i2c_detach_client(client))) {
+               printk
+                   ("vt1211.o: Client deregistration failed, client not detached.\n");
+               return err;
+       }
+
+       release_region(client->addr, VT1211_EXTENT);
+       kfree(client->data);
+
+       return 0;
+}
+
+static inline int vt_rdval(struct i2c_client *client, u8 reg)
+{
+       return (inb_p(client->addr + reg));
+}
+
+static inline void vt1211_write_value(struct i2c_client *client, u8 reg, u8 value)
+{
+       outb_p(value, client->addr + reg);
+}
+
+static void vt1211_init_client(struct i2c_client *client)
+{
+       struct vt1211_data *data = client->data;
+
+       data->vrm = DEFAULT_VRM;
+       /* set "default" interrupt mode for alarms, which isn't the default */
+       vt1211_write_value(client, VT1211_REG_TEMP1_CONFIG, 0);
+       vt1211_write_value(client, VT1211_REG_TEMP2_CONFIG, 0);
+}
+
+static void vt1211_update_client(struct i2c_client *client)
+{
+       struct vt1211_data *data = client->data;
+       int i, j;
+
+       down(&data->update_lock);
+
+       if ((jiffies - data->last_updated > HZ + HZ / 2) ||
+           (jiffies < data->last_updated) || !data->valid) {
+               data->uch_config = vt_rdval(client, VT1211_REG_UCH_CONFIG);
+               for (i = 0; i <= 5; i++) {
+                       if(ISVOLT(i, data->uch_config)) {
+                               data->in[i] = vt_rdval(client, VT1211_REG_IN(i));
+                               data->in_min[i] = vt_rdval(client,
+                                                       VT1211_REG_IN_MIN(i));
+                               data->in_max[i] = vt_rdval(client,
+                                                       VT1211_REG_IN_MAX(i));
+                       } else {
+                               data->in[i] = 0;
+                               data->in_min[i] = 0;
+                               data->in_max[i] = 0;
+                       }
+               }
+               for (i = 1; i <= 2; i++) {
+                       data->fan[i - 1] = vt_rdval(client, VT1211_REG_FAN(i));
+                       data->fan_min[i - 1] = vt_rdval(client,
+                                                    VT1211_REG_FAN_MIN(i));
+               }
+               for (i = 2; i <= 7; i++) {
+                       if(ISTEMP(i, data->uch_config)) {
+                               data->temp[i - 1] = vt_rdval(client,
+                                                    VT1211_REG_TEMP(i)) << 2;
+                               switch(i) {
+                                       case 1:
+                                               /* ? */
+                                               j = 0;
+                                               break;
+                                       case 2:
+                                               j = (vt_rdval(client,
+                                                 VT1211_REG_TEMP_LOW2) &
+                                                                   0x30) >> 4;
+                                               break;
+                                       case 3:
+                                               j = (vt_rdval(client,
+                                                 VT1211_REG_TEMP_LOW3) &
+                                                                   0xc0) >> 6;
+                                               break;
+                                       case 4:
+                                       case 5:
+                                       case 6:
+                                       case 7:
+                                       default:
+                                               j = (vt_rdval(client,
+                                                 VT1211_REG_TEMP_LOW47) >>
+                                                           ((i-4)*2)) & 0x03;  
+                                               break;
+       
+                               }
+                               data->temp[i - 1] |= j;
+                               data->temp_over[i - 1] = vt_rdval(client,
+                                                     VT1211_REG_TEMP_OVER(i));
+                               data->temp_hyst[i - 1] = vt_rdval(client,
+                                                     VT1211_REG_TEMP_HYST(i));
+                       } else {
+                               data->temp[i - 1] = 0;
+                               data->temp_over[i - 1] = 0;
+                               data->temp_hyst[i - 1] = 0;
+                       }
+               }
+
+               for (i = 1; i <= 2; i++) {
+                       data->fan[i - 1] = vt_rdval(client, VT1211_REG_FAN(i));
+                       data->fan_min[i - 1] = vt_rdval(client,
+                                                       VT1211_REG_FAN_MIN(i));
+                       data->pwm[i - 1] = vt_rdval(client, VT1211_REG_PWM(i));
+               }
+
+               data->pwm_ctl = vt_rdval(client, VT1211_REG_PWM_CTL);
+               i = vt_rdval(client, VT1211_REG_FANDIV);
+               data->fan_div[0] = (i >> 4) & 0x03;
+               data->fan_div[1] = i >> 6;
+               data->alarms = vt_rdval(client, VT1211_REG_ALARM1) |
+                                   (vt_rdval(client, VT1211_REG_ALARM2) << 8);
+               data->vid= vt_rdval(client, VT1211_REG_VID) & 0x1f;
+               data->last_updated = jiffies;
+               data->valid = 1;
+       }
+
+       up(&data->update_lock);
+}
+
+
+void vt1211_in(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       struct vt1211_data *data = client->data;
+       int nr = ctl_name - VT1211_SYSCTL_IN0;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 2;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               vt1211_update_client(client);
+               results[0] = IN_FROM_REG(data->in_min[nr]);
+               results[1] = IN_FROM_REG(data->in_max[nr]);
+               results[2] = IN_FROM_REG(data->in[nr]);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->in_min[nr] = IN_TO_REG(results[0]);
+                       vt1211_write_value(client, VT1211_REG_IN_MIN(nr),
+                                           data->in_min[nr]);
+               }
+               if (*nrels_mag >= 2) {
+                       data->in_max[nr] = IN_TO_REG(results[1]);
+                       vt1211_write_value(client, VT1211_REG_IN_MAX(nr),
+                                           data->in_max[nr]);
+               }
+       }
+}
+
+void vt1211_fan(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct vt1211_data *data = client->data;
+       int nr = ctl_name - VT1211_SYSCTL_FAN1 + 1;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               vt1211_update_client(client);
+               results[0] = FAN_FROM_REG(data->fan_min[nr - 1],
+                                         DIV_FROM_REG(data->fan_div
+                                                      [nr - 1]));
+               results[1] = FAN_FROM_REG(data->fan[nr - 1],
+                                DIV_FROM_REG(data->fan_div[nr - 1]));
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->fan_min[nr - 1] = MIN_TO_REG(results[0],
+                                                          DIV_FROM_REG
+                                                          (data->
+                                                           fan_div[nr-1]));
+                       vt1211_write_value(client, VT1211_REG_FAN_MIN(nr),
+                                           data->fan_min[nr - 1]);
+               }
+       }
+}
+
+
+void vt1211_temp(struct i2c_client *client, int operation, int ctl_name,
+                 int *nrels_mag, long *results)
+{
+       struct vt1211_data *data = client->data;
+       int nr = ctl_name - VT1211_SYSCTL_TEMP;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               vt1211_update_client(client);
+               results[0] = TEMP_FROM_REG(data->temp_over[nr]);
+               results[1] = TEMP_FROM_REG(data->temp_hyst[nr]);
+               results[2] = TEMP_FROM_REG10(data->temp[nr]);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->temp_over[nr] = TEMP_TO_REG(results[0]);
+                       vt1211_write_value(client,
+                                           VT1211_REG_TEMP_OVER(nr + 1),
+                                           data->temp_over[nr]);
+               }
+               if (*nrels_mag >= 2) {
+                       data->temp_hyst[nr] = TEMP_TO_REG(results[1]);
+                       vt1211_write_value(client,
+                                           VT1211_REG_TEMP_HYST(nr + 1),
+                                           data->temp_hyst[nr]);
+               }
+       }
+}
+
+void vt1211_alarms(struct i2c_client *client, int operation, int ctl_name,
+                   int *nrels_mag, long *results)
+{
+       struct vt1211_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               vt1211_update_client(client);
+               results[0] = data->alarms;
+               *nrels_mag = 1;
+       }
+}
+
+void vt1211_fan_div(struct i2c_client *client, int operation,
+                    int ctl_name, int *nrels_mag, long *results)
+{
+       struct vt1211_data *data = client->data;
+       int old;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               vt1211_update_client(client);
+               results[0] = DIV_FROM_REG(data->fan_div[0]);
+               results[1] = DIV_FROM_REG(data->fan_div[1]);
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               old = vt_rdval(client, VT1211_REG_FANDIV);
+               if (*nrels_mag >= 2) {
+                       data->fan_div[1] = DIV_TO_REG(results[1]);
+                       old = (old & 0x3f) | (data->fan_div[1] << 6);
+               }
+               if (*nrels_mag >= 1) {
+                       data->fan_div[0] = DIV_TO_REG(results[0]);
+                       old = (old & 0xcf) | (data->fan_div[0] << 4);
+                       vt1211_write_value(client, VT1211_REG_FANDIV, old);
+               }
+       }
+}
+
+void vt1211_pwm(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct vt1211_data *data = client->data;
+       int nr = 1 + ctl_name - VT1211_SYSCTL_PWM1;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               vt1211_update_client(client);
+               results[0] = PWM_FROM_REG(data->pwm[nr - 1]);
+               results[1] = (data->pwm_ctl >> (3 + (4 * (nr - 1)))) & 1;
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->pwm[nr - 1] = PWM_TO_REG(results[0]);
+                       if (*nrels_mag >= 2) {
+                               if(results[1]) {
+                                       data->pwm_ctl |=
+                                                 (0x08 << (4 * (nr - 1)));
+                                       vt1211_write_value(client,
+                                                          VT1211_REG_PWM_CTL, 
+                                                          data->pwm_ctl);
+                               } else {
+                                       data->pwm_ctl &=
+                                               ~ (0x08 << (4 * (nr - 1)));
+                                       vt1211_write_value(client,
+                                                          VT1211_REG_PWM_CTL, 
+                                                          data->pwm_ctl);
+                               }
+                       }
+                       vt1211_write_value(client, VT1211_REG_PWM(nr),
+                                           data->pwm[nr - 1]);
+               }
+       }
+}
+
+void vt1211_vid(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct vt1211_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 3;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               vt1211_update_client(client);
+               results[0] = vid_from_reg(data->vid, data->vrm);
+               *nrels_mag = 1;
+       }
+}
+
+void vt1211_vrm(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct vt1211_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               results[0] = data->vrm;
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1)
+                       data->vrm = results[0];
+       }
+}
+
+void vt1211_uch(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct vt1211_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               results[0] = data->uch_config & 0x7c;
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->uch_config = (data->uch_config & 0x83)|(results[0] & 0x7c);
+                       vt1211_write_value(client, VT1211_REG_UCH_CONFIG,
+                                          data->uch_config);
+               }
+       }
+}
+
+static int __init sm_vt1211_init(void)
+{
+       int addr;
+
+       printk("vt1211.o version %s (%s)\n", LM_VERSION, LM_DATE);
+
+       if (vt1211_find(&addr)) {
+               printk("vt1211.o: VT1211 not detected, module not inserted.\n");
+               return -ENODEV;
+       }
+       normal_isa[0] = addr;
+
+       return i2c_add_driver(&vt1211_driver);
+}
+
+static void __exit sm_vt1211_exit(void)
+{
+       i2c_del_driver(&vt1211_driver);
+}
+
+
+
+MODULE_AUTHOR("Mark D. Studebaker <mdsxyz123@yahoo.com>");
+MODULE_DESCRIPTION("VT1211 sensors");
+MODULE_LICENSE("GPL");
+
+module_init(sm_vt1211_init);
+module_exit(sm_vt1211_exit);
--- linux-old/drivers/sensors/vt8231.c  Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/vt8231.c      Mon Dec 13 20:18:53 2004
@@ -0,0 +1,794 @@
+/*
+    vt8231.c - Part of lm_sensors, Linux kernel modules
+                for hardware monitoring
+                
+    Copyright (c) 2002 Mark D. Studebaker <mdsxyz123@yahoo.com>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/* Supports VIA VT8231 South Bridge embedded sensors */
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/ioport.h>
+#include <linux/pci.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#include <asm/io.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+#include <linux/sensors_vid.h>
+
+
+static int force_addr = 0;
+MODULE_PARM(force_addr, "i");
+MODULE_PARM_DESC(force_addr,
+                "Initialize the base address of the sensors");
+
+static unsigned short normal_i2c[] = { SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { SENSORS_I2C_END };
+static unsigned int normal_isa[] = { 0x0000, SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+SENSORS_INSMOD_1(vt8231);
+
+#define VIA686A_EXTENT 0x80
+#define VIA686A_BASE_REG 0x70
+#define VIA686A_ENABLE_REG 0x74
+
+/* pwm numbered 1-2 */
+#define VT8231_REG_PWM(nr) (0x5f + (nr))
+#define VT8231_REG_PWM_CTL 0x51
+
+/* The VT8231 registers */
+/* We define the sensors as follows. Somewhat convoluted to minimize
+   changes from via686a.
+       Sensor          Voltage Mode    Temp Mode
+       --------        ------------    ---------
+       Reading 1                       temp3
+       Reading 3                       temp1   not in vt8231
+       UCH1/Reading2   in0             temp2
+       UCH2            in1             temp4
+       UCH3            in2             temp5
+       UCH4            in3             temp6
+       UCH5            in4             temp7
+       3.3V            in5
+       -12V            in6                     not in vt8231
+*/
+
+/* ins numbered 0-6 */
+#define VT8231_REG_IN_MAX(nr) ((nr)==0 ? 0x3d : 0x29 + ((nr) * 2))
+#define VT8231_REG_IN_MIN(nr) ((nr)==0 ? 0x3e : 0x2a + ((nr) * 2))
+#define VT8231_REG_IN(nr)     (0x21 + (nr))
+
+/* fans numbered 1-2 */
+#define VT8231_REG_FAN_MIN(nr) (0x3a + (nr))
+#define VT8231_REG_FAN(nr)     (0x28 + (nr))
+
+static const u8 regtemp[] = { 0x20, 0x21, 0x1f, 0x22, 0x23, 0x24, 0x25 };
+static const u8 regover[] = { 0x39, 0x3d, 0x1d, 0x2b, 0x2d, 0x2f, 0x31 };
+static const u8 reghyst[] = { 0x3a, 0x3e, 0x1e, 0x2c, 0x2e, 0x30, 0x32 };
+
+/* temps numbered 1-7 */
+#define VT8231_REG_TEMP(nr)            (regtemp[(nr) - 1])
+#define VT8231_REG_TEMP_OVER(nr)       (regover[(nr) - 1])
+#define VT8231_REG_TEMP_HYST(nr)       (reghyst[(nr) - 1])
+#define VT8231_REG_TEMP_LOW3   0x4b    /* bits 7-6 */
+#define VT8231_REG_TEMP_LOW2   0x49    /* bits 5-4 */
+#define VT8231_REG_TEMP_LOW47  0x4d
+
+#define VT8231_REG_CONFIG 0x40
+#define VT8231_REG_ALARM1 0x41
+#define VT8231_REG_ALARM2 0x42
+#define VT8231_REG_VID    0x45
+#define VT8231_REG_FANDIV 0x47
+#define VT8231_REG_UCH_CONFIG 0x4a
+#define VT8231_REG_TEMP1_CONFIG 0x4b
+#define VT8231_REG_TEMP2_CONFIG 0x4c
+
+/* temps 1-7; voltages 0-6 */
+#define ISTEMP(i, ch_config) ((i) == 1 ? 1 : \
+                             (i) == 3 ? 1 : \
+                             (i) == 2 ? ((ch_config) >> 1) & 0x01 : \
+                                        ((ch_config) >> ((i)-1)) & 0x01)
+#define ISVOLT(i, ch_config) ((i) > 4 ? 1 : !(((ch_config) >> ((i)+2)) & 0x01))
+
+#define DIV_FROM_REG(val) (1 << (val))
+#define DIV_TO_REG(val) ((val)==8?3:(val)==4?2:(val)==1?0:1)
+#define PWM_FROM_REG(val) (val)
+#define PWM_TO_REG(val) SENSORS_LIMIT((val), 0, 255)
+
+#define TEMP_FROM_REG(val) ((val)*10)
+#define TEMP_FROM_REG10(val) (((val)*10)/4)
+#define TEMP_TO_REG(val) (SENSORS_LIMIT(((val)<0?(((val)-5)/10):\
+                                                 ((val)+5)/10),0,255))
+#define IN_FROM_REG(val) /*(((val)*10+5)/10)*/ (val)
+#define IN_TO_REG(val)  (SENSORS_LIMIT((((val) * 10 + 5)/10),0,255))
+
+
+/********* FAN RPM CONVERSIONS ********/
+/* But this chip saturates back at 0, not at 255 like all the other chips.
+   So, 0 means 0 RPM */
+static inline u8 FAN_TO_REG(long rpm, int div)
+{
+       if (rpm == 0)
+               return 0;
+       rpm = SENSORS_LIMIT(rpm, 1, 1000000);
+       return SENSORS_LIMIT((1310720 + rpm * div / 2) / (rpm * div), 1, 255);
+}
+
+#define MIN_TO_REG(a,b) FAN_TO_REG(a,b)
+#define FAN_FROM_REG(val,div) ((val)==0?0:(val)==255?0:1310720/((val)*(div)))
+
+struct vt8231_data {
+       struct i2c_client client;
+       struct semaphore lock;
+       int sysctl_id;
+
+       struct semaphore update_lock;
+       char valid;             /* !=0 if following fields are valid */
+       unsigned long last_updated;     /* In jiffies */
+
+       u8 in[7];               /* Register value */
+       u8 in_max[7];           /* Register value */
+       u8 in_min[7];           /* Register value */
+       u16 temp[7];            /* Register value 10 bit */
+       u8 temp_over[7];        /* Register value */
+       u8 temp_hyst[7];        /* Register value */
+       u8 fan[2];              /* Register value */
+       u8 fan_min[2];          /* Register value */
+       u8 fan_div[2];          /* Register encoding, shifted right */
+       u16 alarms;             /* Register encoding */
+       u8 pwm[2];              /* Register value */
+       u8 pwm_ctl;             /* Register value */
+       u8 vid;                 /* Register encoding */
+       u8 vrm;
+       u8 uch_config;
+};
+
+static int vt8231_attach_adapter(struct i2c_adapter *adapter);
+static int vt8231_detect(struct i2c_adapter *adapter, int address,
+                         unsigned short flags, int kind);
+static int vt8231_detach_client(struct i2c_client *client);
+
+static inline int vt_rdval(struct i2c_client *client, u8 register);
+static inline void vt8231_write_value(struct i2c_client *client, u8 register,
+                              u8 value);
+static void vt8231_update_client(struct i2c_client *client);
+static void vt8231_init_client(struct i2c_client *client);
+static int vt8231_find(int *address);
+
+
+static void vt8231_fan(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void vt8231_alarms(struct i2c_client *client, int operation,
+                          int ctl_name, int *nrels_mag, long *results);
+static void vt8231_fan_div(struct i2c_client *client, int operation,
+                           int ctl_name, int *nrels_mag, long *results);
+static void vt8231_in(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void vt8231_pwm(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void vt8231_vid(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void vt8231_vrm(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void vt8231_uch(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void vt8231_temp(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+
+static int vt8231_id = 0;
+
+static struct i2c_driver vt8231_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "VT8231 sensors driver",
+       .id             = I2C_DRIVERID_VT8231,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = vt8231_attach_adapter,
+       .detach_client  = vt8231_detach_client,
+};
+
+/* -- SENSORS SYSCTL START -- */
+#define VT8231_SYSCTL_IN0 1000
+#define VT8231_SYSCTL_IN1 1001
+#define VT8231_SYSCTL_IN2 1002
+#define VT8231_SYSCTL_IN3 1003
+#define VT8231_SYSCTL_IN4 1004
+#define VT8231_SYSCTL_IN5 1005
+#define VT8231_SYSCTL_IN6 1006
+#define VT8231_SYSCTL_FAN1 1101
+#define VT8231_SYSCTL_FAN2 1102
+#define VT8231_SYSCTL_TEMP 1200
+#define VT8231_SYSCTL_TEMP2 1201
+#define VT8231_SYSCTL_TEMP3 1202
+#define VT8231_SYSCTL_TEMP4 1203
+#define VT8231_SYSCTL_TEMP5 1204
+#define VT8231_SYSCTL_TEMP6 1205
+#define VT8231_SYSCTL_TEMP7 1206
+#define VT8231_SYSCTL_VID      1300
+#define VT8231_SYSCTL_PWM1     1401
+#define VT8231_SYSCTL_PWM2     1402
+#define VT8231_SYSCTL_VRM      1600
+#define VT8231_SYSCTL_UCH      1700
+#define VT8231_SYSCTL_FAN_DIV 2000
+#define VT8231_SYSCTL_ALARMS 2001
+
+#define VT8231_ALARM_IN1 0x01
+#define VT8231_ALARM_IN2 0x02
+#define VT8231_ALARM_IN5 0x04
+#define VT8231_ALARM_IN3 0x08
+#define VT8231_ALARM_TEMP 0x10
+#define VT8231_ALARM_FAN1 0x40
+#define VT8231_ALARM_FAN2 0x80
+#define VT8231_ALARM_IN4 0x100
+#define VT8231_ALARM_IN6 0x200
+#define VT8231_ALARM_TEMP2 0x800
+#define VT8231_ALARM_CHAS 0x1000
+#define VT8231_ALARM_TEMP3 0x8000
+/* duplicates */
+#define VT8231_ALARM_IN0 VT8231_ALARM_TEMP
+#define VT8231_ALARM_TEMP4 VT8231_ALARM_IN1
+#define VT8231_ALARM_TEMP5 VT8231_ALARM_IN2
+#define VT8231_ALARM_TEMP6 VT8231_ALARM_IN3
+#define VT8231_ALARM_TEMP7 VT8231_ALARM_IN4
+
+/* -- SENSORS SYSCTL END -- */
+
+static ctl_table vt8231_dir_table_template[] = {
+       {VT8231_SYSCTL_IN0, "in0", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &vt8231_in},
+       {VT8231_SYSCTL_IN1, "in1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &vt8231_in},
+       {VT8231_SYSCTL_IN2, "in2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &vt8231_in},
+       {VT8231_SYSCTL_IN3, "in3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &vt8231_in},
+       {VT8231_SYSCTL_IN4, "in4", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &vt8231_in},
+       {VT8231_SYSCTL_IN5, "in5", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &vt8231_in},
+/*
+    not in 8231
+       {VT8231_SYSCTL_IN6, "in6", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &vt8231_in},
+       {VT8231_SYSCTL_TEMP, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &vt8231_temp},
+*/
+       {VT8231_SYSCTL_TEMP2, "temp2", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &vt8231_temp},
+       {VT8231_SYSCTL_TEMP3, "temp3", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &vt8231_temp},
+       {VT8231_SYSCTL_TEMP4, "temp4", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &vt8231_temp},
+       {VT8231_SYSCTL_TEMP5, "temp5", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &vt8231_temp},
+       {VT8231_SYSCTL_TEMP6, "temp6", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &vt8231_temp},
+       {VT8231_SYSCTL_TEMP7, "temp7", NULL, 0, 0644, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &vt8231_temp},
+       {VT8231_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &vt8231_fan},
+       {VT8231_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &vt8231_fan},
+       {VT8231_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &vt8231_fan_div},
+       {VT8231_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &vt8231_alarms},
+       {VT8231_SYSCTL_PWM1, "pwm1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &vt8231_pwm},
+       {VT8231_SYSCTL_PWM2, "pwm2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &vt8231_pwm},
+       {VT8231_SYSCTL_VID, "vid", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &vt8231_vid},
+       {VT8231_SYSCTL_VRM, "vrm", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &vt8231_vrm},
+       {VT8231_SYSCTL_UCH, "uch_config", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &vt8231_uch},
+       {0}
+};
+
+static struct pci_dev *s_bridge;
+
+static int vt8231_attach_adapter(struct i2c_adapter *adapter)
+{
+       return i2c_detect(adapter, &addr_data, vt8231_detect);
+}
+
+/* Locate chip and get correct base address */
+static int vt8231_find(int *address)
+{
+       u16 val;
+
+       if (!pci_present())
+               return -ENODEV;
+
+       if (!(s_bridge = pci_find_device(PCI_VENDOR_ID_VIA,
+                                        0x8235, NULL)))
+               return -ENODEV;
+
+       if (PCIBIOS_SUCCESSFUL !=
+           pci_read_config_word(s_bridge, VIA686A_BASE_REG, &val))
+               return -ENODEV;
+       *address = val & ~(VIA686A_EXTENT - 1);
+       if (*address == 0 && force_addr == 0) {
+               printk("vt8231.o: base address not set - upgrade BIOS or use force_addr=0xaddr\n");
+               return -ENODEV;
+       }
+       if (force_addr)
+               *address = force_addr;  /* so detect will get called */
+
+       return 0;
+}
+
+int vt8231_detect(struct i2c_adapter *adapter, int address,
+                  unsigned short flags, int kind)
+{
+       int i;
+       struct i2c_client *new_client;
+       struct vt8231_data *data;
+       int err = 0;
+       const char *type_name = "vt8231";
+       u16 val;
+
+       if (!i2c_is_isa_adapter(adapter)) {
+               return 0;
+       }
+
+       /* 8231 requires multiple of 256 */
+       if(force_addr)
+               address = force_addr & 0xFF00;
+       if (check_region(address, VIA686A_EXTENT)) {
+               printk("vt8231.o: region 0x%x already in use!\n",
+                      address);
+               return -ENODEV;
+       }
+
+       if(force_addr) {
+               printk("vt8231.o: forcing ISA address 0x%04X\n", address);
+               if (PCIBIOS_SUCCESSFUL !=
+                   pci_write_config_word(s_bridge, VIA686A_BASE_REG, address))
+                       return -ENODEV;
+       }
+       if (PCIBIOS_SUCCESSFUL !=
+           pci_read_config_word(s_bridge, VIA686A_ENABLE_REG, &val))
+               return -ENODEV;
+       if (!(val & 0x0001)) {
+               printk("vt8231.o: enabling sensors\n");
+               if (PCIBIOS_SUCCESSFUL !=
+                   pci_write_config_word(s_bridge, VIA686A_ENABLE_REG,
+                                     val | 0x0001))
+                       return -ENODEV;
+       }
+
+       if (!(data = kmalloc(sizeof(struct vt8231_data), GFP_KERNEL))) {
+               err = -ENOMEM;
+               goto ERROR0;
+       }
+
+       new_client = &data->client;
+       new_client->addr = address;
+       init_MUTEX(&data->lock);
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &vt8231_driver;
+       new_client->flags = 0;
+
+       /* Reserve the ISA region */
+       request_region(address, VIA686A_EXTENT, "vt8231-sensors");
+
+       /* Fill in the remaining client fields and put into the global list */
+       strcpy(new_client->name, "Via 8231 Integrated Sensors");
+
+       new_client->id = vt8231_id++;
+       data->valid = 0;
+       init_MUTEX(&data->update_lock);
+
+       /* Tell the I2C layer a new client has arrived */
+       if ((err = i2c_attach_client(new_client)))
+               goto ERROR3;
+
+       /* Register a new directory entry with module sensors */
+       if ((i = i2c_register_entry((struct i2c_client *) new_client,
+                                       type_name,
+                                       vt8231_dir_table_template)) < 0) {
+               err = i;
+               goto ERROR4;
+       }
+       data->sysctl_id = i;
+
+       vt8231_init_client(new_client);
+       return 0;
+
+      ERROR4:
+       i2c_detach_client(new_client);
+      ERROR3:
+       release_region(address, VIA686A_EXTENT);
+       kfree(data);
+      ERROR0:
+       return err;
+}
+
+static int vt8231_detach_client(struct i2c_client *client)
+{
+       int err;
+
+       i2c_deregister_entry(((struct vt8231_data *) (client->data))->
+                                sysctl_id);
+
+       if ((err = i2c_detach_client(client))) {
+               printk
+                   ("vt8231.o: Client deregistration failed, client not detached.\n");
+               return err;
+       }
+
+       release_region(client->addr, VIA686A_EXTENT);
+       kfree(client->data);
+
+       return 0;
+}
+
+
+static inline int vt_rdval(struct i2c_client *client, u8 reg)
+{
+       return (inb_p(client->addr + reg));
+}
+
+static inline void vt8231_write_value(struct i2c_client *client, u8 reg, u8 value)
+{
+       outb_p(value, client->addr + reg);
+}
+
+static void vt8231_init_client(struct i2c_client *client)
+{
+       struct vt8231_data *data = client->data;
+
+       data->vrm = DEFAULT_VRM;
+       /* set "default" interrupt mode for alarms, which isn't the default */
+       vt8231_write_value(client, VT8231_REG_TEMP1_CONFIG, 0);
+       vt8231_write_value(client, VT8231_REG_TEMP2_CONFIG, 0);
+}
+
+static void vt8231_update_client(struct i2c_client *client)
+{
+       struct vt8231_data *data = client->data;
+       int i, j;
+
+       down(&data->update_lock);
+
+       if ((jiffies - data->last_updated > HZ + HZ / 2) ||
+           (jiffies < data->last_updated) || !data->valid) {
+               data->uch_config = vt_rdval(client, VT8231_REG_UCH_CONFIG);
+               for (i = 0; i <= 5; i++) {
+                       if(ISVOLT(i, data->uch_config)) {
+                               data->in[i] = vt_rdval(client, VT8231_REG_IN(i));
+                               data->in_min[i] = vt_rdval(client,
+                                                       VT8231_REG_IN_MIN(i));
+                               data->in_max[i] = vt_rdval(client,
+                                                       VT8231_REG_IN_MAX(i));
+                       } else {
+                               data->in[i] = 0;
+                               data->in_min[i] = 0;
+                               data->in_max[i] = 0;
+                       }
+               }
+               for (i = 1; i <= 2; i++) {
+                       data->fan[i - 1] = vt_rdval(client, VT8231_REG_FAN(i));
+                       data->fan_min[i - 1] = vt_rdval(client,
+                                                    VT8231_REG_FAN_MIN(i));
+               }
+               for (i = 2; i <= 7; i++) {
+                       if(ISTEMP(i, data->uch_config)) {
+                               data->temp[i - 1] = vt_rdval(client,
+                                                    VT8231_REG_TEMP(i)) << 2;
+                               switch(i) {
+                                       case 1:
+                                               /* ? */
+                                               j = 0;
+                                               break;
+                                       case 2:
+                                               j = (vt_rdval(client,
+                                                 VT8231_REG_TEMP_LOW2) &
+                                                                   0x30) >> 4;
+                                               break;
+                                       case 3:
+                                               j = (vt_rdval(client,
+                                                 VT8231_REG_TEMP_LOW3) &
+                                                                   0xc0) >> 6;
+                                               break;
+                                       case 4:
+                                       case 5:
+                                       case 6:
+                                       case 7:
+                                       default:
+                                               j = (vt_rdval(client,
+                                                 VT8231_REG_TEMP_LOW47) >>
+                                                           ((i-4)*2)) & 0x03;  
+                                               break;
+       
+                               }
+                               data->temp[i - 1] |= j;
+                               data->temp_over[i - 1] = vt_rdval(client,
+                                                     VT8231_REG_TEMP_OVER(i));
+                               data->temp_hyst[i - 1] = vt_rdval(client,
+                                                     VT8231_REG_TEMP_HYST(i));
+                       } else {
+                               data->temp[i - 1] = 0;
+                               data->temp_over[i - 1] = 0;
+                               data->temp_hyst[i - 1] = 0;
+                       }
+               }
+
+               for (i = 1; i <= 2; i++) {
+                       data->fan[i - 1] = vt_rdval(client, VT8231_REG_FAN(i));
+                       data->fan_min[i - 1] = vt_rdval(client,
+                                                       VT8231_REG_FAN_MIN(i));
+                       data->pwm[i - 1] = vt_rdval(client, VT8231_REG_PWM(i));
+               }
+
+               data->pwm_ctl = vt_rdval(client, VT8231_REG_PWM_CTL);
+               i = vt_rdval(client, VT8231_REG_FANDIV);
+               data->fan_div[0] = (i >> 4) & 0x03;
+               data->fan_div[1] = i >> 6;
+               data->alarms = vt_rdval(client, VT8231_REG_ALARM1) |
+                                   (vt_rdval(client, VT8231_REG_ALARM2) << 8);
+               data->vid= vt_rdval(client, VT8231_REG_VID) & 0x1f;
+               data->last_updated = jiffies;
+               data->valid = 1;
+       }
+
+       up(&data->update_lock);
+}
+
+
+void vt8231_in(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       struct vt8231_data *data = client->data;
+       int nr = ctl_name - VT8231_SYSCTL_IN0;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 2;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               vt8231_update_client(client);
+               results[0] = IN_FROM_REG(data->in_min[nr]);
+               results[1] = IN_FROM_REG(data->in_max[nr]);
+               results[2] = IN_FROM_REG(data->in[nr]);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->in_min[nr] = IN_TO_REG(results[0]);
+                       vt8231_write_value(client, VT8231_REG_IN_MIN(nr),
+                                           data->in_min[nr]);
+               }
+               if (*nrels_mag >= 2) {
+                       data->in_max[nr] = IN_TO_REG(results[1]);
+                       vt8231_write_value(client, VT8231_REG_IN_MAX(nr),
+                                           data->in_max[nr]);
+               }
+       }
+}
+
+void vt8231_fan(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct vt8231_data *data = client->data;
+       int nr = ctl_name - VT8231_SYSCTL_FAN1 + 1;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               vt8231_update_client(client);
+               results[0] = FAN_FROM_REG(data->fan_min[nr - 1],
+                                         DIV_FROM_REG(data->fan_div
+                                                      [nr - 1]));
+               results[1] = FAN_FROM_REG(data->fan[nr - 1],
+                                DIV_FROM_REG(data->fan_div[nr - 1]));
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->fan_min[nr - 1] = MIN_TO_REG(results[0],
+                                                          DIV_FROM_REG
+                                                          (data->
+                                                           fan_div[nr-1]));
+                       vt8231_write_value(client, VT8231_REG_FAN_MIN(nr),
+                                           data->fan_min[nr - 1]);
+               }
+       }
+}
+
+
+void vt8231_temp(struct i2c_client *client, int operation, int ctl_name,
+                 int *nrels_mag, long *results)
+{
+       struct vt8231_data *data = client->data;
+       int nr = ctl_name - VT8231_SYSCTL_TEMP;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               vt8231_update_client(client);
+               results[0] = TEMP_FROM_REG(data->temp_over[nr]);
+               results[1] = TEMP_FROM_REG(data->temp_hyst[nr]);
+               results[2] = TEMP_FROM_REG10(data->temp[nr]);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->temp_over[nr] = TEMP_TO_REG(results[0]);
+                       vt8231_write_value(client,
+                                           VT8231_REG_TEMP_OVER(nr + 1),
+                                           data->temp_over[nr]);
+               }
+               if (*nrels_mag >= 2) {
+                       data->temp_hyst[nr] = TEMP_TO_REG(results[1]);
+                       vt8231_write_value(client,
+                                           VT8231_REG_TEMP_HYST(nr + 1),
+                                           data->temp_hyst[nr]);
+               }
+       }
+}
+
+void vt8231_alarms(struct i2c_client *client, int operation, int ctl_name,
+                   int *nrels_mag, long *results)
+{
+       struct vt8231_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               vt8231_update_client(client);
+               results[0] = data->alarms;
+               *nrels_mag = 1;
+       }
+}
+
+void vt8231_fan_div(struct i2c_client *client, int operation,
+                    int ctl_name, int *nrels_mag, long *results)
+{
+       struct vt8231_data *data = client->data;
+       int old;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               vt8231_update_client(client);
+               results[0] = DIV_FROM_REG(data->fan_div[0]);
+               results[1] = DIV_FROM_REG(data->fan_div[1]);
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               old = vt_rdval(client, VT8231_REG_FANDIV);
+               if (*nrels_mag >= 2) {
+                       data->fan_div[1] = DIV_TO_REG(results[1]);
+                       old = (old & 0x3f) | (data->fan_div[1] << 6);
+               }
+               if (*nrels_mag >= 1) {
+                       data->fan_div[0] = DIV_TO_REG(results[0]);
+                       old = (old & 0xcf) | (data->fan_div[0] << 4);
+                       vt8231_write_value(client, VT8231_REG_FANDIV, old);
+               }
+       }
+}
+
+void vt8231_pwm(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct vt8231_data *data = client->data;
+       int nr = 1 + ctl_name - VT8231_SYSCTL_PWM1;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               vt8231_update_client(client);
+               results[0] = PWM_FROM_REG(data->pwm[nr - 1]);
+               results[1] = (data->pwm_ctl >> (3 + (4 * (nr - 1)))) & 1;
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->pwm[nr - 1] = PWM_TO_REG(results[0]);
+                       if (*nrels_mag >= 2) {
+                               if(results[1]) {
+                                       data->pwm_ctl |=
+                                                 (0x08 << (4 * (nr - 1)));
+                                       vt8231_write_value(client,
+                                                          VT8231_REG_PWM_CTL, 
+                                                          data->pwm_ctl);
+                               } else {
+                                       data->pwm_ctl &=
+                                               ~ (0x08 << (4 * (nr - 1)));
+                                       vt8231_write_value(client,
+                                                          VT8231_REG_PWM_CTL, 
+                                                          data->pwm_ctl);
+                               }
+                       }
+                       vt8231_write_value(client, VT8231_REG_PWM(nr),
+                                           data->pwm[nr - 1]);
+               }
+       }
+}
+
+void vt8231_vid(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct vt8231_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 3;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               vt8231_update_client(client);
+               results[0] = vid_from_reg(data->vid, data->vrm);
+               *nrels_mag = 1;
+       }
+}
+
+void vt8231_vrm(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct vt8231_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               results[0] = data->vrm;
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1)
+                       data->vrm = results[0];
+       }
+}
+
+void vt8231_uch(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct vt8231_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               results[0] = data->uch_config & 0x7c;
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->uch_config = (data->uch_config & 0x83)|(results[0] & 0x7c);
+                       vt8231_write_value(client, VT8231_REG_UCH_CONFIG,
+                                          data->uch_config);
+               }
+       }
+}
+
+static int __init sm_vt8231_init(void)
+{
+       int addr;
+
+       printk("vt8231.o version %s (%s)\n", LM_VERSION, LM_DATE);
+
+       if (vt8231_find(&addr)) {
+               printk("vt8231.o: VT8231 not detected, module not inserted.\n");
+               return -ENODEV;
+       }
+       normal_isa[0] = addr;
+
+       return i2c_add_driver(&vt8231_driver);}
+
+static void __exit sm_vt8231_exit(void)
+{
+       i2c_del_driver(&vt8231_driver);
+}
+
+
+
+MODULE_AUTHOR("Mark D. Studebaker <mdsxyz123@yahoo.com>");
+MODULE_DESCRIPTION("VT8231 sensors");
+MODULE_LICENSE("GPL");
+
+module_init(sm_vt8231_init);
+module_exit(sm_vt8231_exit);
--- linux-old/drivers/sensors/w83627hf.c        Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/w83627hf.c    Mon Dec 13 20:18:53 2004
@@ -0,0 +1,1422 @@
+/*
+    w83627hf.c - Part of lm_sensors, Linux kernel modules for hardware
+                monitoring
+    Copyright (c) 1998 - 2003  Frodo Looijaard <frodol@dds.nl>,
+    Philip Edelbrock <phil@netroedge.com>,
+    and Mark Studebaker <mdsxyz123@yahoo.com>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+    Supports following chips:
+
+    Chip       #vin    #fanin  #pwm    #temp   wchipid vendid  i2c     ISA
+    w83627hf   9       3       2       3       0x20    0x5ca3  no      yes(LPC)
+    w83627thf  7       3       3       3       0x90    0x5ca3  no      yes(LPC)
+    w83637hf   7       3       3       3       0x80    0x5ca3  no      yes(LPC)
+    w83697hf   8       2       2       2       0x60    0x5ca3  no      yes(LPC)
+
+    For other winbond chips, and for i2c support in the above chips,
+    use w83781d.c.
+
+    Note: automatic ("cruise") fan control for 697, 637 & 627thf not
+    supported yet.
+*/
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/ioport.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#include <asm/io.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+#include <linux/sensors_vid.h>
+#include "lm75.h"
+
+static int force_addr;
+MODULE_PARM(force_addr, "i");
+MODULE_PARM_DESC(force_addr,
+                "Initialize the base address of the sensors");
+static int force_i2c = 0x1f;
+MODULE_PARM(force_i2c, "i");
+MODULE_PARM_DESC(force_i2c,
+                "Initialize the i2c address of the sensors");
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = { SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { SENSORS_I2C_END };
+static unsigned int normal_isa[] = { 0, SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+/* Insmod parameters */
+SENSORS_INSMOD_4(w83627hf, w83627thf, w83697hf, w83637hf);
+
+static int init = 1;
+MODULE_PARM(init, "i");
+MODULE_PARM_DESC(init, "Set to zero to bypass chip initialization");
+
+/* modified from kernel/include/traps.c */
+#define        REG     0x2e    /* The register to read/write */
+#define        DEV     0x07    /* Register: Logical device select */
+#define        VAL     0x2f    /* The value to read/write */
+
+/* logical device numbers for superio_select (below) */
+#define W83627HF_LD_FDC                0x00
+#define W83627HF_LD_PRT                0x01
+#define W83627HF_LD_UART1      0x02
+#define W83627HF_LD_UART2      0x03
+#define W83627HF_LD_KBC                0x05
+#define W83627HF_LD_CIR                0x06 /* w83627hf only */
+#define W83627HF_LD_GAME       0x07
+#define W83627HF_LD_MIDI       0x07
+#define W83627HF_LD_GPIO1      0x07
+#define W83627HF_LD_GPIO5      0x07 /* w83627thf only */
+#define W83627HF_LD_GPIO2      0x08
+#define W83627HF_LD_GPIO3      0x09
+#define W83627HF_LD_GPIO4      0x09 /* w83627thf only */
+#define W83627HF_LD_ACPI       0x0a
+#define W83627HF_LD_HWM                0x0b
+
+#define        DEVID   0x20    /* Register: Device ID */
+
+#define W83627THF_GPIO5_IOSR   0xf3 /* w83627thf only */
+#define W83627THF_GPIO5_DR     0xf4 /* w83627thf only */
+#define W83627THF_GPIO5_INVR   0xf5 /* w83627thf only */
+
+static inline void
+superio_outb(int reg, int val)
+{
+       outb(reg, REG);
+       outb(val, VAL);
+}
+
+static inline int
+superio_inb(int reg)
+{
+       outb(reg, REG);
+       return inb(VAL);
+}
+
+static inline void
+superio_select(int ld)
+{
+       outb(DEV, REG);
+       outb(ld, VAL);
+}
+
+static inline void
+superio_enter(void)
+{
+       outb(0x87, REG);
+       outb(0x87, REG);
+}
+
+static inline void
+superio_exit(void)
+{
+       outb(0xAA, REG);
+}
+
+#define W627_DEVID 0x52
+#define W627THF_DEVID 0x82
+#define W697_DEVID 0x60
+#define W637_DEVID 0x70
+#define WINB_ACT_REG 0x30
+#define WINB_BASE_REG 0x60
+/* Constants specified below */
+
+/* Length of ISA address segment */
+#define WINB_EXTENT 8
+
+/* Where are the ISA address/data registers relative to the base address */
+#define W83781D_ADDR_REG_OFFSET 5
+#define W83781D_DATA_REG_OFFSET 6
+
+/* The W83781D registers */
+/* The W83782D registers for nr=7,8 are in bank 5 */
+#define W83781D_REG_IN_MAX(nr) ((nr < 7) ? (0x2b + (nr) * 2) : \
+                                          (0x554 + (((nr) - 7) * 2)))
+#define W83781D_REG_IN_MIN(nr) ((nr < 7) ? (0x2c + (nr) * 2) : \
+                                          (0x555 + (((nr) - 7) * 2)))
+#define W83781D_REG_IN(nr)     ((nr < 7) ? (0x20 + (nr)) : \
+                                          (0x550 + (nr) - 7))
+
+#define W83781D_REG_FAN_MIN(nr) (0x3a + (nr))
+#define W83781D_REG_FAN(nr) (0x27 + (nr))
+
+#define W83781D_REG_TEMP2 0x0150
+#define W83781D_REG_TEMP3 0x0250
+#define W83781D_REG_TEMP2_HYST 0x153
+#define W83781D_REG_TEMP3_HYST 0x253
+#define W83781D_REG_TEMP2_CONFIG 0x152
+#define W83781D_REG_TEMP3_CONFIG 0x252
+#define W83781D_REG_TEMP2_OVER 0x155
+#define W83781D_REG_TEMP3_OVER 0x255
+
+#define W83781D_REG_TEMP 0x27
+#define W83781D_REG_TEMP_OVER 0x39
+#define W83781D_REG_TEMP_HYST 0x3A
+#define W83781D_REG_BANK 0x4E
+
+#define W83781D_REG_CONFIG 0x40
+#define W83781D_REG_ALARM1 0x41
+#define W83781D_REG_ALARM2 0x42
+#define W83781D_REG_ALARM3 0x450
+
+#define W83781D_REG_IRQ 0x4C
+#define W83781D_REG_BEEP_CONFIG 0x4D
+#define W83781D_REG_BEEP_INTS1 0x56
+#define W83781D_REG_BEEP_INTS2 0x57
+#define W83781D_REG_BEEP_INTS3 0x453
+
+#define W83781D_REG_VID_FANDIV 0x47
+
+#define W83781D_REG_CHIPID 0x49
+#define W83781D_REG_WCHIPID 0x58
+#define W83781D_REG_CHIPMAN 0x4F
+#define W83781D_REG_PIN 0x4B
+
+#define W83781D_REG_VBAT 0x5D
+
+#define W83627HF_REG_PWM1 0x5A
+#define W83627HF_REG_PWM2 0x5B
+#define W83627HF_REG_PWMCLK12 0x5C
+
+#define W83627THF_REG_PWM1             0x01    /* 697HF and 637HF too */
+#define W83627THF_REG_PWM2             0x03    /* 697HF and 637HF too */
+#define W83627THF_REG_PWM3             0x11    /* 637HF too */
+
+#define W83627THF_REG_VRM_OVT_CFG      0x18    /* 637HF too */
+
+static const u8 regpwm_627hf[] = { W83627HF_REG_PWM1, W83627HF_REG_PWM2 };
+static const u8 regpwm[] = { W83627THF_REG_PWM1, W83627THF_REG_PWM2,
+                             W83627THF_REG_PWM3 };
+#define W836X7HF_REG_PWM(type, nr) (((type) == w83627hf) ? \
+                                     regpwm_627hf[(nr) - 1] : regpwm[(nr) - 1])
+
+#define W83781D_REG_I2C_ADDR 0x48
+#define W83781D_REG_I2C_SUBADDR 0x4A
+
+/* Sensor selection */
+#define W83781D_REG_SCFG1 0x5D
+static const u8 BIT_SCFG1[] = { 0x02, 0x04, 0x08 };
+#define W83781D_REG_SCFG2 0x59
+static const u8 BIT_SCFG2[] = { 0x10, 0x20, 0x40 };
+#define W83781D_DEFAULT_BETA 3435
+
+/* Conversions. Limit checking is only done on the TO_REG
+   variants. Note that you should be a bit careful with which arguments
+   these macros are called: arguments may be evaluated more than once.
+   Fixing this is just not worth it. */
+#define IN_TO_REG(val)  (SENSORS_LIMIT((((val) * 10 + 8)/16),0,255))
+#define IN_FROM_REG(val) (((val) * 16 + 5) / 10)
+
+#define IN_TO_REG_VRM9(val) \
+       (SENSORS_LIMIT((((val) * 1000 - 70000 + 244) / 488), 0, 255))
+#define IN_FROM_REG_VRM9(reg)  (((reg) * 488 + 70000 + 500) / 1000)
+
+static inline u8 FAN_TO_REG(long rpm, int div)
+{
+       if (rpm == 0)
+               return 255;
+       rpm = SENSORS_LIMIT(rpm, 1, 1000000);
+       return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1,
+                            254);
+}
+
+#define TEMP_MIN (-1280)
+#define TEMP_MAX ( 1270)
+
+/* TEMP: 1/10 degrees C (-128C to +127C)
+   REG: 1C/bit, two's complement */
+static u8 TEMP_TO_REG(int temp)
+{
+        int ntemp = SENSORS_LIMIT(temp, TEMP_MIN, TEMP_MAX);
+        ntemp += (ntemp<0 ? -5 : 5);
+        return (u8)(ntemp / 10);
+}
+                                                                                
+static int TEMP_FROM_REG(u8 reg)
+{
+        return (s8)reg * 10;
+}
+
+#define FAN_FROM_REG(val,div) ((val)==0?-1:(val)==255?0:1350000/((val)*(div)))
+
+#define PWM_TO_REG(val) (SENSORS_LIMIT((val),0,255))
+#define BEEPS_TO_REG(val) ((val) & 0xffffff)
+
+#define BEEP_ENABLE_TO_REG(val)   ((val)?1:0)
+#define BEEP_ENABLE_FROM_REG(val) ((val)?1:0)
+
+#define DIV_FROM_REG(val) (1 << (val))
+
+static inline u8 DIV_TO_REG(long val)
+{
+       int i;
+       val = SENSORS_LIMIT(val, 1, 128) >> 1;
+       for (i = 0; i < 6; i++) {
+               if (val == 0)
+                       break;
+               val >>= 1;
+       }
+       return ((u8) i);
+}
+
+/* For each registered chip, we need to keep some data in memory. That
+   data is pointed to by w83627hf_list[NR]->data. The structure itself is
+   dynamically allocated, at the same time when a new client is allocated. */
+struct w83627hf_data {
+       struct i2c_client client;
+       struct semaphore lock;
+       int sysctl_id;
+       enum chips type;
+
+       struct semaphore update_lock;
+       char valid;             /* !=0 if following fields are valid */
+       unsigned long last_updated;     /* In jiffies */
+
+       struct i2c_client *lm75;        /* for secondary I2C addresses */
+       /* pointer to array of 2 subclients */
+
+       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;
+       u8 temp_over;           /* Register value */
+       u8 temp_hyst;           /* Register value */
+       u16 temp_add[2];        /* Register value */
+       u16 temp_add_over[2];   /* Register value */
+       u16 temp_add_hyst[2];   /* Register value */
+       u8 fan_div[3];          /* Register encoding, shifted right */
+       u8 vid;                 /* Register encoding, combined */
+       u32 alarms;             /* Register encoding, combined */
+       u32 beeps;              /* Register encoding, combined */
+       u8 beep_enable;         /* Boolean */
+       u8 pwm[3];              /* Register value */
+       u8 pwmenable[3];        /* bool */
+       u16 sens[3];            /* 782D/783S only.
+                                  1 = pentium diode; 2 = 3904 diode;
+                                  3000-5000 = thermistor beta.
+                                  Default = 3435. 
+                                  Other Betas unimplemented */
+       u8 vrm;
+       u8 vrm_ovt;             /* Register value, 627thf & 637hf only */
+};
+
+
+static int w83627hf_attach_adapter(struct i2c_adapter *adapter);
+static int w83627hf_detect(struct i2c_adapter *adapter, int address,
+                         unsigned short flags, int kind);
+static int w83627hf_detach_client(struct i2c_client *client);
+
+static int w83627hf_read_value(struct i2c_client *client, u16 register);
+static int w83627hf_write_value(struct i2c_client *client, u16 register,
+                              u16 value);
+static void w83627hf_update_client(struct i2c_client *client);
+static void w83627hf_init_client(struct i2c_client *client);
+
+
+static void w83627hf_in(struct i2c_client *client, int operation,
+                      int ctl_name, int *nrels_mag, long *results);
+static void w83627hf_fan(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void w83627hf_temp(struct i2c_client *client, int operation,
+                        int ctl_name, int *nrels_mag, long *results);
+static void w83627hf_temp_add(struct i2c_client *client, int operation,
+                            int ctl_name, int *nrels_mag, long *results);
+static void w83627hf_vid(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void w83627hf_vrm(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void w83627hf_alarms(struct i2c_client *client, int operation,
+                          int ctl_name, int *nrels_mag, long *results);
+static void w83627hf_beep(struct i2c_client *client, int operation,
+                        int ctl_name, int *nrels_mag, long *results);
+static void w83627hf_fan_div(struct i2c_client *client, int operation,
+                           int ctl_name, int *nrels_mag, long *results);
+static void w83627hf_pwm(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void w83627hf_sens(struct i2c_client *client, int operation,
+                        int ctl_name, int *nrels_mag, long *results);
+
+static int w83627hf_id = 0;
+
+static struct i2c_driver w83627hf_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "W83627HF sensor driver",
+       .id             = I2C_DRIVERID_W83627HF,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = w83627hf_attach_adapter,
+       .detach_client  = w83627hf_detach_client,
+};
+
+/* The /proc/sys entries */
+/* WARNING these are copied from w83781d.c and have not been renamed.
+   Note that the 627hf and 697hf are supported by both drivers.
+   Do not make incompatible changes here or we will have errors
+   in the generated file ../include/sensors.h !!!
+*/
+/* -- SENSORS SYSCTL START -- */
+
+#define W83781D_SYSCTL_IN0 1000        /* Volts * 100 */
+#define W83781D_SYSCTL_IN1 1001
+#define W83781D_SYSCTL_IN2 1002
+#define W83781D_SYSCTL_IN3 1003
+#define W83781D_SYSCTL_IN4 1004
+#define W83781D_SYSCTL_IN5 1005
+#define W83781D_SYSCTL_IN6 1006
+#define W83781D_SYSCTL_IN7 1007
+#define W83781D_SYSCTL_IN8 1008
+#define W83781D_SYSCTL_FAN1 1101       /* Rotations/min */
+#define W83781D_SYSCTL_FAN2 1102
+#define W83781D_SYSCTL_FAN3 1103
+#define W83781D_SYSCTL_TEMP1 1200      /* Degrees Celcius * 10 */
+#define W83781D_SYSCTL_TEMP2 1201      /* Degrees Celcius * 10 */
+#define W83781D_SYSCTL_TEMP3 1202      /* Degrees Celcius * 10 */
+#define W83781D_SYSCTL_VID 1300                /* Volts * 1000 */
+#define W83781D_SYSCTL_VRM 1301
+#define W83781D_SYSCTL_PWM1 1401
+#define W83781D_SYSCTL_PWM2 1402
+#define W83781D_SYSCTL_PWM3 1403
+#define W83781D_SYSCTL_SENS1 1501      /* 1, 2, or Beta (3000-5000) */
+#define W83781D_SYSCTL_SENS2 1502
+#define W83781D_SYSCTL_SENS3 1503
+#define W83781D_SYSCTL_FAN_DIV 2000    /* 1, 2, 4 or 8 */
+#define W83781D_SYSCTL_ALARMS 2001     /* bitvector */
+#define W83781D_SYSCTL_BEEP 2002       /* bitvector */
+
+#define W83781D_ALARM_IN0 0x0001
+#define W83781D_ALARM_IN1 0x0002
+#define W83781D_ALARM_IN2 0x0004
+#define W83781D_ALARM_IN3 0x0008
+#define W83781D_ALARM_IN4 0x0100
+#define W83781D_ALARM_IN5 0x0200
+#define W83781D_ALARM_IN6 0x0400
+#define W83782D_ALARM_IN7 0x10000
+#define W83782D_ALARM_IN8 0x20000
+#define W83781D_ALARM_FAN1 0x0040
+#define W83781D_ALARM_FAN2 0x0080
+#define W83781D_ALARM_FAN3 0x0800
+#define W83781D_ALARM_TEMP1 0x0010
+#define W83781D_ALARM_TEMP23 0x0020    /* 781D only */
+#define W83781D_ALARM_TEMP2 0x0020     /* 782D/783S */
+#define W83781D_ALARM_TEMP3 0x2000     /* 782D only */
+#define W83781D_ALARM_CHAS 0x1000
+
+/* -- SENSORS SYSCTL END -- */
+
+/* These files are created for each detected chip. This is just a template;
+   though at first sight, you might think we could use a statically
+   allocated list, we need some way to get back to the parent - which
+   is done through one of the 'extra' fields which are initialized 
+   when a new copy is allocated. */
+
+/* without pwm3-4 */
+static ctl_table w83627hf_dir_table_template[] = {
+       {W83781D_SYSCTL_IN0, "in0", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_in},
+       {W83781D_SYSCTL_IN1, "in1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_in},
+       {W83781D_SYSCTL_IN2, "in2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_in},
+       {W83781D_SYSCTL_IN3, "in3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_in},
+       {W83781D_SYSCTL_IN4, "in4", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_in},
+       {W83781D_SYSCTL_IN5, "in5", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_in},
+       {W83781D_SYSCTL_IN6, "in6", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_in},
+       {W83781D_SYSCTL_IN7, "in7", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_in},
+       {W83781D_SYSCTL_IN8, "in8", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_in},
+       {W83781D_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_fan},
+       {W83781D_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_fan},
+       {W83781D_SYSCTL_FAN3, "fan3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_fan},
+       {W83781D_SYSCTL_TEMP1, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_temp},
+       {W83781D_SYSCTL_TEMP2, "temp2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_temp_add},
+       {W83781D_SYSCTL_TEMP3, "temp3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_temp_add},
+       {W83781D_SYSCTL_VID, "vid", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_vid},
+       {W83781D_SYSCTL_VRM, "vrm", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_vrm},
+       {W83781D_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_fan_div},
+       {W83781D_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_alarms},
+       {W83781D_SYSCTL_BEEP, "beep", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_beep},
+       {W83781D_SYSCTL_PWM1, "pwm1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_pwm},
+       {W83781D_SYSCTL_PWM2, "pwm2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_pwm},
+       {W83781D_SYSCTL_SENS1, "sensor1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_sens},
+       {W83781D_SYSCTL_SENS2, "sensor2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_sens},
+       {W83781D_SYSCTL_SENS3, "sensor3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_sens},
+       {0}
+};
+
+/* similar to w83782d but no fan3, no vid */
+static ctl_table w83697hf_dir_table_template[] = {
+       {W83781D_SYSCTL_IN0, "in0", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_in},
+       /* no in1 to maintain compatibility with 781d and 782d. */
+       {W83781D_SYSCTL_IN2, "in2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_in},
+       {W83781D_SYSCTL_IN3, "in3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_in},
+       {W83781D_SYSCTL_IN4, "in4", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_in},
+       {W83781D_SYSCTL_IN5, "in5", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_in},
+       {W83781D_SYSCTL_IN6, "in6", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_in},
+       {W83781D_SYSCTL_IN7, "in7", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_in},
+       {W83781D_SYSCTL_IN8, "in8", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_in},
+       {W83781D_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_fan},
+       {W83781D_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_fan},
+       {W83781D_SYSCTL_TEMP1, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_temp},
+       {W83781D_SYSCTL_TEMP2, "temp2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_temp_add},
+       {W83781D_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_fan_div},
+       {W83781D_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_alarms},
+       {W83781D_SYSCTL_BEEP, "beep", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_beep},
+       {W83781D_SYSCTL_PWM1, "pwm1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_pwm},
+       {W83781D_SYSCTL_PWM2, "pwm2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_pwm},
+       {W83781D_SYSCTL_SENS1, "sensor1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_sens},
+       {W83781D_SYSCTL_SENS2, "sensor2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_sens},
+       {0}
+};
+
+/* no in5 and in6 */
+/* We use this one for W83637HF too */
+static ctl_table w83627thf_dir_table_template[] = {
+       {W83781D_SYSCTL_IN0, "in0", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_in},
+       {W83781D_SYSCTL_IN1, "in1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_in},
+       {W83781D_SYSCTL_IN2, "in2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_in},
+       {W83781D_SYSCTL_IN3, "in3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_in},
+       {W83781D_SYSCTL_IN4, "in4", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_in},
+       {W83781D_SYSCTL_IN7, "in7", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_in},
+       {W83781D_SYSCTL_IN8, "in8", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_in},
+       {W83781D_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_fan},
+       {W83781D_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_fan},
+       {W83781D_SYSCTL_FAN3, "fan3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_fan},
+       {W83781D_SYSCTL_TEMP1, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_temp},
+       {W83781D_SYSCTL_TEMP2, "temp2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_temp_add},
+       {W83781D_SYSCTL_TEMP3, "temp3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_temp_add},
+       {W83781D_SYSCTL_VID, "vid", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_vid},
+       {W83781D_SYSCTL_VRM, "vrm", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_vrm},
+       {W83781D_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_fan_div},
+       {W83781D_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_alarms},
+       {W83781D_SYSCTL_BEEP, "beep", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_beep},
+       {W83781D_SYSCTL_PWM1, "pwm1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_pwm},
+       {W83781D_SYSCTL_PWM2, "pwm2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_pwm},
+       {W83781D_SYSCTL_PWM3, "pwm3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_pwm},
+       {W83781D_SYSCTL_SENS1, "sensor1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_sens},
+       {W83781D_SYSCTL_SENS2, "sensor2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_sens},
+       {W83781D_SYSCTL_SENS3, "sensor3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83627hf_sens},
+       {0}
+};
+
+
+/* This function is called when:
+     * w83627hf_driver is inserted (when this module is loaded), for each
+       available adapter
+     * when a new adapter is inserted (and w83627hf_driver is still present) */
+static int w83627hf_attach_adapter(struct i2c_adapter *adapter)
+{
+       return i2c_detect(adapter, &addr_data, w83627hf_detect);
+}
+
+static int w83627hf_find(int *address)
+{
+       u16 val;
+
+       superio_enter();
+       val= superio_inb(DEVID);
+       if(val != W627_DEVID && val !=W627THF_DEVID && val != W697_DEVID && val != W637_DEVID) {
+               superio_exit();
+               return -ENODEV;
+       }
+
+       superio_select(W83627HF_LD_HWM);
+       val = (superio_inb(WINB_BASE_REG) << 8) |
+              superio_inb(WINB_BASE_REG + 1);
+       *address = val & ~(WINB_EXTENT - 1);
+       if (*address == 0 && force_addr == 0) {
+               printk("w83627hf.o: base address not set - use force_addr=0xaddr\n");
+               superio_exit();
+               return -ENODEV;
+       }
+       if (force_addr)
+               *address = force_addr;  /* so detect will get called */
+
+       superio_exit();
+       return 0;
+}
+
+int w83627hf_detect(struct i2c_adapter *adapter, int address,
+                  unsigned short flags, int kind)
+{
+       int i, val;
+       struct i2c_client *new_client;
+       struct w83627hf_data *data;
+       int err = 0;
+       const char *type_name = "";
+       const char *client_name = "";
+
+       if (!i2c_is_isa_adapter(adapter))
+               return 0;
+
+       if(force_addr)
+               address = force_addr & ~(WINB_EXTENT - 1);
+       if (check_region(address, WINB_EXTENT)) {
+               printk("w83627hf.o: region 0x%x already in use!\n", address);
+               return -ENODEV;
+       }
+       if(force_addr) {
+               printk("w83627hf.o: forcing ISA address 0x%04X\n", address);
+               superio_enter();
+               superio_select(W83627HF_LD_HWM);
+               superio_outb(WINB_BASE_REG, address >> 8);
+               superio_outb(WINB_BASE_REG+1, address & 0xff);
+               superio_exit();
+       }
+
+       superio_enter();
+       val= superio_inb(DEVID);
+       if(val == W627_DEVID)
+               kind = w83627hf;
+       else if(val == W697_DEVID)
+               kind = w83697hf;
+       else if(val == W627THF_DEVID)
+               kind = w83627thf;
+       else if(val == W637_DEVID)
+               kind = w83637hf;
+               
+       superio_select(W83627HF_LD_HWM);
+       if((val = 0x01 & superio_inb(WINB_ACT_REG)) == 0)
+               superio_outb(WINB_ACT_REG, 1);
+       superio_exit();
+
+       /* OK. For now, we presume we have a valid client. We now create the
+          client structure, even though we cannot fill it completely yet.
+          But it allows us to access w83627hf_{read,write}_value. */
+
+       if (!(data = kmalloc(sizeof(struct w83627hf_data), GFP_KERNEL))) {
+               err = -ENOMEM;
+               goto ERROR0;
+       }
+
+       new_client = &data->client;
+       new_client->addr = address;
+       init_MUTEX(&data->lock);
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &w83627hf_driver;
+       new_client->flags = 0;
+
+
+       if (kind == w83627hf) {
+               type_name = "w83627hf";
+               client_name = "W83627HF chip";
+       } else if (kind == w83627thf) {
+               type_name = "w83627thf";
+               client_name = "W83627THF chip";
+       } else if (kind == w83697hf) {
+               type_name = "w83697hf";
+               client_name = "W83697HF chip";
+       } else if (kind == w83637hf) {
+               type_name = "w83637hf";
+               client_name = "W83637HF chip";
+       } else {
+               goto ERROR1;
+       }
+
+       request_region(address, WINB_EXTENT, type_name);
+
+       /* Fill in the remaining client fields and put it into the global list */
+       strcpy(new_client->name, client_name);
+       data->type = kind;
+       new_client->id = w83627hf_id++;
+       data->valid = 0;
+       init_MUTEX(&data->update_lock);
+
+       /* Tell the I2C layer a new client has arrived */
+       if ((err = i2c_attach_client(new_client)))
+               goto ERROR3;
+
+       data->lm75 = NULL;
+
+       /* Register a new directory entry with module sensors */
+       if ((i = i2c_register_entry(new_client,
+                               type_name,
+                               (kind == w83697hf) ?
+                                  w83697hf_dir_table_template :
+                               (kind == w83627hf) ?
+                                  w83627hf_dir_table_template :
+                                  /* w83627thf table also used for 637 */
+                                  w83627thf_dir_table_template)) < 0) {
+               err = i;
+               goto ERROR7;
+       }
+       data->sysctl_id = i;
+
+       /* Initialize the chip */
+       w83627hf_init_client(new_client);
+       return 0;
+
+/* OK, this is not exactly good programming practice, usually. But it is
+   very code-efficient in this case. */
+
+      ERROR7:
+       i2c_detach_client(new_client);
+      ERROR3:
+       release_region(address, WINB_EXTENT);
+      ERROR1:
+       kfree(data);
+      ERROR0:
+       return err;
+}
+
+static int w83627hf_detach_client(struct i2c_client *client)
+{
+       int err;
+
+       i2c_deregister_entry(((struct w83627hf_data *) (client->data))->
+                                sysctl_id);
+
+       if ((err = i2c_detach_client(client))) {
+               printk
+                   (KERN_ERR "w83627hf.o: Client deregistration failed, client not detached.\n");
+               return err;
+       }
+
+       release_region(client->addr, WINB_EXTENT);
+       kfree(client->data);
+
+       return 0;
+}
+
+
+/*
+   ISA access must always be locked explicitly! 
+   We ignore the W83781D BUSY flag at this moment - it could lead to deadlocks,
+   would slow down the W83781D access and should not be necessary. 
+   There are some ugly typecasts here, but the good news is - they should
+   nowhere else be necessary! */
+static int w83627hf_read_value(struct i2c_client *client, u16 reg)
+{
+       int res, word_sized;
+
+       down(&(((struct w83627hf_data *) (client->data))->lock));
+       word_sized = (((reg & 0xff00) == 0x100)
+                     || ((reg & 0xff00) == 0x200))
+           && (((reg & 0x00ff) == 0x50)
+               || ((reg & 0x00ff) == 0x53)
+               || ((reg & 0x00ff) == 0x55));
+       if (reg & 0xff00) {
+               outb_p(W83781D_REG_BANK,
+                      client->addr + W83781D_ADDR_REG_OFFSET);
+               outb_p(reg >> 8,
+                      client->addr + W83781D_DATA_REG_OFFSET);
+       }
+       outb_p(reg & 0xff, client->addr + W83781D_ADDR_REG_OFFSET);
+       res = inb_p(client->addr + W83781D_DATA_REG_OFFSET);
+       if (word_sized) {
+               outb_p((reg & 0xff) + 1,
+                      client->addr + W83781D_ADDR_REG_OFFSET);
+               res =
+                   (res << 8) + inb_p(client->addr +
+                                      W83781D_DATA_REG_OFFSET);
+       }
+       if (reg & 0xff00) {
+               outb_p(W83781D_REG_BANK,
+                      client->addr + W83781D_ADDR_REG_OFFSET);
+               outb_p(0, client->addr + W83781D_DATA_REG_OFFSET);
+       }
+       up(&(((struct w83627hf_data *) (client->data))->lock));
+       return res;
+}
+
+static int w83627thf_read_gpio5(struct i2c_client *client)
+{
+       int res, inv;
+
+       down(&(((struct w83627hf_data *) (client->data))->lock));
+       superio_enter();
+       superio_select(W83627HF_LD_GPIO5);
+       res = superio_inb(W83627THF_GPIO5_DR);
+       inv = superio_inb(W83627THF_GPIO5_INVR);
+       superio_exit();
+       up(&(((struct w83627hf_data *) (client->data))->lock));
+       return res;
+}
+
+static int w83627hf_write_value(struct i2c_client *client, u16 reg, u16 value)
+{
+       int word_sized;
+
+       down(&(((struct w83627hf_data *) (client->data))->lock));
+       word_sized = (((reg & 0xff00) == 0x100)
+                     || ((reg & 0xff00) == 0x200))
+           && (((reg & 0x00ff) == 0x53)
+               || ((reg & 0x00ff) == 0x55));
+       if (reg & 0xff00) {
+               outb_p(W83781D_REG_BANK,
+                      client->addr + W83781D_ADDR_REG_OFFSET);
+               outb_p(reg >> 8,
+                      client->addr + W83781D_DATA_REG_OFFSET);
+       }
+       outb_p(reg & 0xff, client->addr + W83781D_ADDR_REG_OFFSET);
+       if (word_sized) {
+               outb_p(value >> 8,
+                      client->addr + W83781D_DATA_REG_OFFSET);
+               outb_p((reg & 0xff) + 1,
+                      client->addr + W83781D_ADDR_REG_OFFSET);
+       }
+       outb_p(value & 0xff,
+              client->addr + W83781D_DATA_REG_OFFSET);
+       if (reg & 0xff00) {
+               outb_p(W83781D_REG_BANK,
+                      client->addr + W83781D_ADDR_REG_OFFSET);
+               outb_p(0, client->addr + W83781D_DATA_REG_OFFSET);
+       }
+       up(&(((struct w83627hf_data *) (client->data))->lock));
+       return 0;
+}
+
+/* Called when we have found a new W83781D. It should set limits, etc. */
+static void w83627hf_init_client(struct i2c_client *client)
+{
+       struct w83627hf_data *data = client->data;
+       int i;
+       int type = data->type;
+       u8 tmp;
+
+       /* Minimize conflicts with other winbond i2c-only clients...  */
+       /* disable i2c subclients... how to disable main i2c client?? */
+       /* force i2c address to relatively uncommon address */
+       w83627hf_write_value(client, W83781D_REG_I2C_SUBADDR, 0x89);
+       w83627hf_write_value(client, W83781D_REG_I2C_ADDR, force_i2c);
+
+       /* Read VID only once */
+       if (w83627hf == data->type || w83637hf == data->type) {
+               int lo = w83627hf_read_value(client, W83781D_REG_VID_FANDIV);
+               int hi = w83627hf_read_value(client, W83781D_REG_CHIPID);
+               data->vid = (lo & 0x0f) | ((hi & 0x01) << 4);
+       } else if (w83627thf == data->type) {
+               data->vid = w83627thf_read_gpio5(client) & 0x1f;
+       }
+
+       /* Read VRM & OVT Config only once */
+       if (w83627thf == data->type || w83637hf == data->type)
+               data->vrm_ovt =
+                       w83627hf_read_value(client, W83627THF_REG_VRM_OVT_CFG);
+       else
+               data->vrm_ovt = 0;
+
+       /* Choose VRM based on "VRM & OVT" register */
+       data->vrm = (data->vrm_ovt & 0x01) ? 90 : 82;
+
+       tmp = w83627hf_read_value(client, W83781D_REG_SCFG1);
+       for (i = 1; i <= 3; i++) {
+               if (!(tmp & BIT_SCFG1[i - 1])) {
+                       data->sens[i - 1] = W83781D_DEFAULT_BETA;
+               } else {
+                       if (w83627hf_read_value
+                           (client,
+                            W83781D_REG_SCFG2) & BIT_SCFG2[i - 1])
+                               data->sens[i - 1] = 1;
+                       else
+                               data->sens[i - 1] = 2;
+               }
+               if ((type == w83697hf) && (i == 2))
+                       break;
+       }
+
+       data->pwmenable[0] = 1;
+       data->pwmenable[1] = 1;
+       data->pwmenable[2] = 1;
+
+       if(init) {
+               if (type == w83627hf) {
+                       /* enable PWM2 control (can't hurt since PWM reg
+                          should have been reset to 0xff) */
+                       w83627hf_write_value(client, W83627HF_REG_PWMCLK12, 0x19);
+               }
+               /* enable comparator mode for temp2 and temp3 so
+                  alarm indication will work correctly */
+               i = w83627hf_read_value(client, W83781D_REG_IRQ);
+               if (!(i & 0x40))
+                       w83627hf_write_value(client, W83781D_REG_IRQ,
+                                           i | 0x40);
+       }
+
+       /* Start monitoring */
+       w83627hf_write_value(client, W83781D_REG_CONFIG,
+                           (w83627hf_read_value(client,
+                                               W83781D_REG_CONFIG) & 0xf7)
+                           | 0x01);
+}
+
+static void w83627hf_update_client(struct i2c_client *client)
+{
+       struct w83627hf_data *data = client->data;
+       int i;
+
+       down(&data->update_lock);
+
+       if ((jiffies - data->last_updated > HZ + HZ / 2) ||
+           (jiffies < data->last_updated) || !data->valid) {
+               for (i = 0; i <= 8; i++) {
+                       /* skip missing sensors */
+                       if (((data->type == w83697hf) && (i == 1)) ||
+                           ((data->type == w83627thf || data->type == w83637hf) &&
+                            (i == 4 || i == 5)))
+                               continue;
+                       data->in[i] =
+                           w83627hf_read_value(client, W83781D_REG_IN(i));
+                       data->in_min[i] =
+                           w83627hf_read_value(client,
+                                              W83781D_REG_IN_MIN(i));
+                       data->in_max[i] =
+                           w83627hf_read_value(client,
+                                              W83781D_REG_IN_MAX(i));
+               }
+               for (i = 1; i <= 3; i++) {
+                       data->fan[i - 1] =
+                           w83627hf_read_value(client, W83781D_REG_FAN(i));
+                       data->fan_min[i - 1] =
+                           w83627hf_read_value(client,
+                                              W83781D_REG_FAN_MIN(i));
+               }
+               for (i = 1; i <= 3; i++) {
+                       u8 tmp = w83627hf_read_value(client,
+                               W836X7HF_REG_PWM(data->type, i));
+                       if (data->type == w83627thf)
+                               tmp &= 0xf0; /* bits 0-3 are reserved  in 627THF */
+                       data->pwm[i - 1] = tmp;
+                       if(i == 2 && (data->type == w83627hf || data->type == w83697hf))
+                               break;
+               }
+
+               data->temp = w83627hf_read_value(client, W83781D_REG_TEMP);
+               data->temp_over =
+                   w83627hf_read_value(client, W83781D_REG_TEMP_OVER);
+               data->temp_hyst =
+                   w83627hf_read_value(client, W83781D_REG_TEMP_HYST);
+               data->temp_add[0] =
+                   w83627hf_read_value(client, W83781D_REG_TEMP2);
+               data->temp_add_over[0] =
+                   w83627hf_read_value(client, W83781D_REG_TEMP2_OVER);
+               data->temp_add_hyst[0] =
+                   w83627hf_read_value(client, W83781D_REG_TEMP2_HYST);
+               if (data->type != w83697hf) {
+                       data->temp_add[1] =
+                           w83627hf_read_value(client, W83781D_REG_TEMP3);
+                       data->temp_add_over[1] =
+                           w83627hf_read_value(client, W83781D_REG_TEMP3_OVER);
+                       data->temp_add_hyst[1] =
+                           w83627hf_read_value(client, W83781D_REG_TEMP3_HYST);
+               }
+
+               i = w83627hf_read_value(client, W83781D_REG_VID_FANDIV);
+               data->fan_div[0] = (i >> 4) & 0x03;
+               data->fan_div[1] = (i >> 6) & 0x03;
+               if (data->type != w83697hf) {
+                       data->fan_div[2] = (w83627hf_read_value(client,
+                                              W83781D_REG_PIN) >> 6) & 0x03;
+               }
+               i = w83627hf_read_value(client, W83781D_REG_VBAT);
+               data->fan_div[0] |= (i >> 3) & 0x04;
+               data->fan_div[1] |= (i >> 4) & 0x04;
+               if (data->type != w83697hf)
+                       data->fan_div[2] |= (i >> 5) & 0x04;
+               data->alarms =
+                   w83627hf_read_value(client, W83781D_REG_ALARM1) |
+                   (w83627hf_read_value(client, W83781D_REG_ALARM2) << 8) |
+                   (w83627hf_read_value(client, W83781D_REG_ALARM3) << 16);
+               i = w83627hf_read_value(client, W83781D_REG_BEEP_INTS2);
+               data->beep_enable = i >> 7;
+               data->beeps = ((i & 0x7f) << 8) |
+                   w83627hf_read_value(client, W83781D_REG_BEEP_INTS1) |
+                   w83627hf_read_value(client, W83781D_REG_BEEP_INTS3) << 16;
+               data->last_updated = jiffies;
+               data->valid = 1;
+       }
+
+       up(&data->update_lock);
+}
+
+void w83627hf_in(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       struct w83627hf_data *data = client->data;
+       int nr = ctl_name - W83781D_SYSCTL_IN0;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 2;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               w83627hf_update_client(client);
+
+               if (nr == 0 && (data->vrm_ovt & 0x01)) {
+                       /* use VRM9 calculation */
+                       results[0] = IN_FROM_REG_VRM9(data->in_min[0]);
+                       results[1] = IN_FROM_REG_VRM9(data->in_max[0]);
+                       results[2] = IN_FROM_REG_VRM9(data->in[0]);
+
+               } else {
+                       /* use VRM8 (standard) calculation */
+                       results[0] = IN_FROM_REG(data->in_min[nr]);
+                       results[1] = IN_FROM_REG(data->in_max[nr]);
+                       results[2] = IN_FROM_REG(data->in[nr]);
+               }
+
+               *nrels_mag = 3;
+
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       if (nr == 0 && (data->vrm_ovt & 0x01))
+                               /* use VRM9 calculation */
+                               data->in_min[0] = IN_TO_REG_VRM9(results[0]);
+                       else
+                               /* use VRM8 (standard) calculation */
+                               data->in_min[nr] = IN_TO_REG(results[0]);
+
+                       w83627hf_write_value(client, W83781D_REG_IN_MIN(nr),
+                                           data->in_min[nr]);
+               }
+               if (*nrels_mag >= 2) {
+                       if (nr == 0 && (data->vrm_ovt & 0x01))
+                               /* use VRM9 calculation */
+                               data->in_min[0] = IN_TO_REG_VRM9(results[1]);
+                       else
+                               /* use VRM8 (standard) calculation */
+                               data->in_max[nr] = IN_TO_REG(results[1]);
+
+                       w83627hf_write_value(client, W83781D_REG_IN_MAX(nr),
+                                           data->in_max[nr]);
+               }
+       }
+}
+
+void w83627hf_fan(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct w83627hf_data *data = client->data;
+       int nr = ctl_name - W83781D_SYSCTL_FAN1 + 1;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               w83627hf_update_client(client);
+               results[0] = FAN_FROM_REG(data->fan_min[nr - 1],
+                                 DIV_FROM_REG(data->fan_div[nr - 1]));
+               results[1] = FAN_FROM_REG(data->fan[nr - 1],
+                                 DIV_FROM_REG(data->fan_div[nr - 1]));
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->fan_min[nr - 1] =
+                            FAN_TO_REG(results[0],
+                                   DIV_FROM_REG(data->fan_div[nr-1]));
+                       w83627hf_write_value(client,
+                                           W83781D_REG_FAN_MIN(nr),
+                                           data->fan_min[nr - 1]);
+               }
+       }
+}
+
+void w83627hf_temp(struct i2c_client *client, int operation, int ctl_name,
+                 int *nrels_mag, long *results)
+{
+       struct w83627hf_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               w83627hf_update_client(client);
+               results[0] = TEMP_FROM_REG(data->temp_over);
+               results[1] = TEMP_FROM_REG(data->temp_hyst);
+               results[2] = TEMP_FROM_REG(data->temp);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->temp_over = TEMP_TO_REG(results[0]);
+                       w83627hf_write_value(client, W83781D_REG_TEMP_OVER,
+                                           data->temp_over);
+               }
+               if (*nrels_mag >= 2) {
+                       data->temp_hyst = TEMP_TO_REG(results[1]);
+                       w83627hf_write_value(client, W83781D_REG_TEMP_HYST,
+                                           data->temp_hyst);
+               }
+       }
+}
+
+void w83627hf_temp_add(struct i2c_client *client, int operation,
+                     int ctl_name, int *nrels_mag, long *results)
+{
+       struct w83627hf_data *data = client->data;
+       int nr = ctl_name - W83781D_SYSCTL_TEMP2;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               w83627hf_update_client(client);
+                       results[0] =
+                           LM75_TEMP_FROM_REG(data->temp_add_over[nr]);
+                       results[1] =
+                           LM75_TEMP_FROM_REG(data->temp_add_hyst[nr]);
+                       results[2] = LM75_TEMP_FROM_REG(data->temp_add[nr]);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                               data->temp_add_over[nr] =
+                                   LM75_TEMP_TO_REG(results[0]);
+                       w83627hf_write_value(client,
+                                           nr ? W83781D_REG_TEMP3_OVER :
+                                           W83781D_REG_TEMP2_OVER,
+                                           data->temp_add_over[nr]);
+               }
+               if (*nrels_mag >= 2) {
+                               data->temp_add_hyst[nr] =
+                                   LM75_TEMP_TO_REG(results[1]);
+                       w83627hf_write_value(client,
+                                           nr ? W83781D_REG_TEMP3_HYST :
+                                           W83781D_REG_TEMP2_HYST,
+                                           data->temp_add_hyst[nr]);
+               }
+       }
+}
+
+void w83627hf_vid(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct w83627hf_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 3;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               w83627hf_update_client(client);
+               results[0] = vid_from_reg(data->vid, data->vrm);
+               *nrels_mag = 1;
+       }
+}
+
+void w83627hf_vrm(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct w83627hf_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               results[0] = data->vrm;
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1)
+                       data->vrm = results[0];
+       }
+}
+
+void w83627hf_alarms(struct i2c_client *client, int operation, int ctl_name,
+                   int *nrels_mag, long *results)
+{
+       struct w83627hf_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               w83627hf_update_client(client);
+               results[0] = data->alarms;
+               *nrels_mag = 1;
+       }
+}
+
+void w83627hf_beep(struct i2c_client *client, int operation, int ctl_name,
+                 int *nrels_mag, long *results)
+{
+       struct w83627hf_data *data = client->data;
+       int val;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               w83627hf_update_client(client);
+               results[0] = BEEP_ENABLE_FROM_REG(data->beep_enable);
+               results[1] = data->beeps;
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 2) {
+                       data->beeps = BEEPS_TO_REG(results[1]);
+                       w83627hf_write_value(client, W83781D_REG_BEEP_INTS1,
+                                           data->beeps & 0xff);
+                               w83627hf_write_value(client,
+                                                   W83781D_REG_BEEP_INTS3,
+                                                   ((data-> beeps) >> 16) &
+                                                     0xff);
+                       val = (data->beeps >> 8) & 0x7f;
+               } else if (*nrels_mag >= 1)
+                       val =
+                           w83627hf_read_value(client,
+                                              W83781D_REG_BEEP_INTS2) &
+                           0x7f;
+               if (*nrels_mag >= 1) {
+                       data->beep_enable = BEEP_ENABLE_TO_REG(results[0]);
+                       w83627hf_write_value(client, W83781D_REG_BEEP_INTS2,
+                                           val | data->beep_enable << 7);
+               }
+       }
+}
+
+/* w83697hf only has two fans */
+void w83627hf_fan_div(struct i2c_client *client, int operation,
+                    int ctl_name, int *nrels_mag, long *results)
+{
+       struct w83627hf_data *data = client->data;
+       int old, old2, old3 = 0;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               w83627hf_update_client(client);
+               results[0] = DIV_FROM_REG(data->fan_div[0]);
+               results[1] = DIV_FROM_REG(data->fan_div[1]);
+               if (data->type == w83697hf) {
+                       *nrels_mag = 2;
+               } else {
+                       results[2] = DIV_FROM_REG(data->fan_div[2]);
+                       *nrels_mag = 3;
+               }
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               old = w83627hf_read_value(client, W83781D_REG_VID_FANDIV);
+               /* w83627hf doesn't have extended divisor bits */
+                       old3 =
+                           w83627hf_read_value(client, W83781D_REG_VBAT);
+               if (*nrels_mag >= 3 && data->type != w83697hf) {
+                       data->fan_div[2] =
+                           DIV_TO_REG(results[2]);
+                       old2 = w83627hf_read_value(client, W83781D_REG_PIN);
+                       old2 =
+                           (old2 & 0x3f) | ((data->fan_div[2] & 0x03) << 6);
+                       w83627hf_write_value(client, W83781D_REG_PIN, old2);
+                               old3 =
+                                   (old3 & 0x7f) |
+                                   ((data->fan_div[2] & 0x04) << 5);
+               }
+               if (*nrels_mag >= 2) {
+                       data->fan_div[1] =
+                           DIV_TO_REG(results[1]);
+                       old =
+                           (old & 0x3f) | ((data->fan_div[1] & 0x03) << 6);
+                               old3 =
+                                   (old3 & 0xbf) |
+                                   ((data->fan_div[1] & 0x04) << 4);
+               }
+               if (*nrels_mag >= 1) {
+                       data->fan_div[0] =
+                           DIV_TO_REG(results[0]);
+                       old =
+                           (old & 0xcf) | ((data->fan_div[0] & 0x03) << 4);
+                       w83627hf_write_value(client, W83781D_REG_VID_FANDIV,
+                                           old);
+                               old3 =
+                                   (old3 & 0xdf) |
+                                   ((data->fan_div[0] & 0x04) << 3);
+                               w83627hf_write_value(client,
+                                                   W83781D_REG_VBAT,
+                                                   old3);
+               }
+       }
+}
+
+/* we do not currently support disabling PWM with 2nd argument;
+  set first argument to 255 to disable */
+void w83627hf_pwm(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct w83627hf_data *data = client->data;
+       int nr = 1 + ctl_name - W83781D_SYSCTL_PWM1;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               w83627hf_update_client(client);
+               results[0] = data->pwm[nr - 1];
+               results[1] = data->pwmenable[nr - 1];
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       if (data->type == w83627thf) {
+                               /* bits 0-3 are reserved  in 627THF */
+                               data->pwm[nr - 1] = PWM_TO_REG(results[0]) & 0xf0;
+                               w83627hf_write_value(client,
+                                                    W836X7HF_REG_PWM(data->type, nr),
+                                                    data->pwm[nr - 1] |
+                                                    (w83627hf_read_value(client,
+                                                     W836X7HF_REG_PWM(data->type, nr)) & 0x0f));
+                       } else {
+                               data->pwm[nr - 1] = PWM_TO_REG(results[0]);
+                               w83627hf_write_value(client,
+                                                    W836X7HF_REG_PWM(data->type, nr),
+                                                    data->pwm[nr - 1]);
+                       }
+               }
+       }
+}
+
+void w83627hf_sens(struct i2c_client *client, int operation, int ctl_name,
+                 int *nrels_mag, long *results)
+{
+       struct w83627hf_data *data = client->data;
+       int nr = 1 + ctl_name - W83781D_SYSCTL_SENS1;
+       u8 tmp;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               results[0] = data->sens[nr - 1];
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       switch (results[0]) {
+                       case 1: /* PII/Celeron diode */
+                               tmp = w83627hf_read_value(client,
+                                                      W83781D_REG_SCFG1);
+                               w83627hf_write_value(client,
+                                                   W83781D_REG_SCFG1,
+                                                   tmp | BIT_SCFG1[nr -
+                                                                   1]);
+                               tmp = w83627hf_read_value(client,
+                                                      W83781D_REG_SCFG2);
+                               w83627hf_write_value(client,
+                                                   W83781D_REG_SCFG2,
+                                                   tmp | BIT_SCFG2[nr -
+                                                                   1]);
+                               data->sens[nr - 1] = results[0];
+                               break;
+                       case 2: /* 3904 */
+                               tmp = w83627hf_read_value(client,
+                                                      W83781D_REG_SCFG1);
+                               w83627hf_write_value(client,
+                                                   W83781D_REG_SCFG1,
+                                                   tmp | BIT_SCFG1[nr -
+                                                                   1]);
+                               tmp = w83627hf_read_value(client,
+                                                      W83781D_REG_SCFG2);
+                               w83627hf_write_value(client,
+                                                   W83781D_REG_SCFG2,
+                                                   tmp & ~BIT_SCFG2[nr -
+                                                                    1]);
+                               data->sens[nr - 1] = results[0];
+                               break;
+                       case W83781D_DEFAULT_BETA:      /* thermistor */
+                               tmp = w83627hf_read_value(client,
+                                                      W83781D_REG_SCFG1);
+                               w83627hf_write_value(client,
+                                                   W83781D_REG_SCFG1,
+                                                   tmp & ~BIT_SCFG1[nr -
+                                                                    1]);
+                               data->sens[nr - 1] = results[0];
+                               break;
+                       default:
+                               printk
+                                   (KERN_ERR "w83627hf.o: Invalid sensor type %ld; must be 1, 2, or %d\n",
+                                    results[0], W83781D_DEFAULT_BETA);
+                               break;
+                       }
+               }
+       }
+}
+
+static int __init sm_w83627hf_init(void)
+{
+       int addr;
+
+       printk(KERN_INFO "w83627hf.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       if (w83627hf_find(&addr)) {
+               printk("w83627hf.o: W83627/697 not detected, module not inserted.\n");
+               return -ENODEV;
+       }
+       normal_isa[0] = addr;
+
+       return i2c_add_driver(&w83627hf_driver);
+}
+
+static void __exit sm_w83627hf_exit(void)
+{
+       i2c_del_driver(&w83627hf_driver);
+}
+
+
+
+MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>, "
+             "Philip Edelbrock <phil@netroedge.com>, "
+             "and Mark Studebaker <mdsxyz123@yahoo.com>");
+MODULE_DESCRIPTION("W83627HF driver");
+MODULE_LICENSE("GPL");
+
+module_init(sm_w83627hf_init);
+module_exit(sm_w83627hf_exit);
--- linux-old/drivers/sensors/w83781d.c Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/w83781d.c     Mon Dec 13 20:18:54 2004
@@ -0,0 +1,1957 @@
+/*
+    w83781d.c - Part of lm_sensors, Linux kernel modules for hardware
+                monitoring
+    Copyright (c) 1998 - 2003  Frodo Looijaard <frodol@dds.nl>,
+    Philip Edelbrock <phil@netroedge.com>,
+    and Mark Studebaker <mdsxyz123@yahoo.com>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+    Supports following chips:
+
+    Chip       #vin    #fanin  #pwm    #temp   wchipid vendid  i2c     ISA
+    as99127f   7       3       0       3       0x31    0x12c3  yes     no
+    as99127f rev.2 (type name = as99127f)      0x31    0x5ca3  yes     no
+    w83627hf   9       3       2       3       0x21    0x5ca3  yes     yes(LPC)
+    w83697hf   8       2       2       2       0x60    0x5ca3  no      yes(LPC)
+    w83781d    7       3       0       3       0x10-1  0x5ca3  yes     yes
+    w83782d    9       3       2-4     3       0x30    0x5ca3  yes     yes
+    w83783s    5-6     3       2       1-2     0x40    0x5ca3  yes     no
+    w83791d    10      5       5       3       0x71    0x5ca3  yes     no
+
+*/
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/ioport.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#include <asm/io.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+#include <linux/sensors_vid.h>
+#include "lm75.h"
+
+/* RT Table support #defined so we can take it out if it gets bothersome */
+#define W83781D_RT 1
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = { SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { 0x20, 0x2f, SENSORS_I2C_END };
+static unsigned int normal_isa[] = { 0x0290, SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+/* Insmod parameters */
+SENSORS_INSMOD_7(w83781d, w83782d, w83783s, w83627hf, as99127f, w83697hf, w83791d);
+SENSORS_MODULE_PARM(force_subclients, "List of subclient addresses: " \
+                      "{bus, clientaddr, subclientaddr1, subclientaddr2}");
+
+static int init = 1;
+MODULE_PARM(init, "i");
+MODULE_PARM_DESC(init, "Set to zero to bypass chip initialization");
+
+/* Constants specified below */
+
+/* Length of ISA address segment */
+#define W83781D_EXTENT 8
+
+/* Where are the ISA address/data registers relative to the base address */
+#define W83781D_ADDR_REG_OFFSET 5
+#define W83781D_DATA_REG_OFFSET 6
+
+/* The W83781D registers */
+/* The W83782D registers for nr=7,8 are in bank 5 */
+#define W83781D_REG_IN_MAX(nr) ((nr < 7) ? (0x2b + (nr) * 2) : \
+                                          (0x554 + (((nr) - 7) * 2)))
+#define W83781D_REG_IN_MIN(nr) ((nr < 7) ? (0x2c + (nr) * 2) : \
+                                          (0x555 + (((nr) - 7) * 2)))
+#define W83781D_REG_IN(nr)     ((nr < 7) ? (0x20 + (nr)) : \
+                                          (0x550 + (nr) - 7))
+
+#define W83791D_REG_IN_MAX(nr) ((nr < 7) ? (0x2b + (nr) * 2) : \
+                                          (0xb4 + (((nr) - 7) * 2)))
+#define W83791D_REG_IN_MIN(nr) ((nr < 7) ? (0x2c + (nr) * 2) : \
+                                          (0xb5 + (((nr) - 7) * 2)))
+#define W83791D_REG_IN(nr)     ((nr < 7) ? (0x20 + (nr)) : \
+                                          (0xb0 + (nr) - 7))
+
+#define W83781D_REG_FAN_MIN(nr) ((nr < 4) ? (0x3a + (nr)) : \
+                                            (0xba + (nr) - 4))
+#define W83781D_REG_FAN(nr)     ((nr < 4) ? (0x27 + (nr)) : \
+                                            (0xbc + (nr) - 4))
+
+#define W83781D_REG_TEMP2 0x0150
+#define W83781D_REG_TEMP3 0x0250
+#define W83781D_REG_TEMP2_HYST 0x153
+#define W83781D_REG_TEMP3_HYST 0x253
+#define W83781D_REG_TEMP2_CONFIG 0x152
+#define W83781D_REG_TEMP3_CONFIG 0x252
+#define W83781D_REG_TEMP2_OVER 0x155
+#define W83781D_REG_TEMP3_OVER 0x255
+
+#define W83781D_REG_TEMP 0x27
+#define W83781D_REG_TEMP_OVER 0x39
+#define W83781D_REG_TEMP_HYST 0x3A
+#define W83781D_REG_BANK 0x4E
+
+#define W83781D_REG_CONFIG 0x40
+#define W83781D_REG_ALARM1 0x41
+#define W83781D_REG_ALARM2 0x42
+#define W83781D_REG_ALARM3 0x450       /* not on W83781D */
+
+#define W83781D_REG_IRQ 0x4C
+#define W83781D_REG_BEEP_CONFIG 0x4D
+#define W83781D_REG_BEEP_INTS1 0x56
+#define W83781D_REG_BEEP_INTS2 0x57
+#define W83781D_REG_BEEP_INTS3 0x453   /* not on W83781D */
+
+#define W83781D_REG_VID_FANDIV 0x47
+
+#define W83781D_REG_CHIPID 0x49
+#define W83781D_REG_WCHIPID 0x58
+#define W83781D_REG_CHIPMAN 0x4F
+#define W83781D_REG_PIN 0x4B
+
+/* 782D/783S only */
+#define W83781D_REG_VBAT 0x5D
+
+/* PWM 782D (1-4) and 783S (1-2) only */
+#define W83781D_REG_PWM1 0x5B  /* 782d and 783s/627hf datasheets disagree */
+                               /* on which is which; */
+#define W83781D_REG_PWM2 0x5A  /* We follow the 782d convention here, */
+                               /* However 782d is probably wrong. */
+#define W83781D_REG_PWM3 0x5E
+#define W83781D_REG_PWM4 0x5F
+#define W83781D_REG_PWMCLK12 0x5C
+#define W83781D_REG_PWMCLK34 0x45C
+
+#define W83791D_REG_PWM1 0x81
+#define W83791D_REG_PWM2 0x83
+#define W83791D_REG_PWM3 0x94
+
+#define W83627HF_REG_PWM1 0x01
+#define W83627HF_REG_PWM2 0x03
+#define W83627HF_REG_PWMCLK1 0x00
+#define W83627HF_REG_PWMCLK2 0x02
+
+static const u8 regpwm[] = { W83781D_REG_PWM1, W83781D_REG_PWM2,
+       W83781D_REG_PWM3, W83781D_REG_PWM4
+};
+
+static const u8 regpwm_w83791d[] = { W83791D_REG_PWM1, W83791D_REG_PWM2,
+                                   W83791D_REG_PWM3
+};
+        
+#define W83781D_REG_PWM(type, nr) (((type) == w83791d) ? \
+                                         regpwm_w83791d[(nr) - 1] : \
+                                   ((type) == w83697hf) ? \
+                                         (((nr) * 2) - 1) : \
+                                         regpwm[(nr) - 1])
+
+#define W83781D_REG_I2C_ADDR 0x48
+#define W83781D_REG_I2C_SUBADDR 0x4A
+
+/* The following are undocumented in the data sheets however we
+   received the information in an email from Winbond tech support */
+/* Sensor selection - not on 781d */
+#define W83781D_REG_SCFG1 0x5D
+static const u8 BIT_SCFG1[] = { 0x02, 0x04, 0x08 };
+#define W83781D_REG_SCFG2 0x59
+static const u8 BIT_SCFG2[] = { 0x10, 0x20, 0x40 };
+#define W83781D_DEFAULT_BETA 3435
+
+/* RT Table registers */
+#define W83781D_REG_RT_IDX 0x50
+#define W83781D_REG_RT_VAL 0x51
+
+/* Conversions. Rounding and limit checking is only done on the TO_REG
+   variants. Note that you should be a bit careful with which arguments
+   these macros are called: arguments may be evaluated more than once.
+   Fixing this is just not worth it. */
+#define IN_TO_REG(val)  (SENSORS_LIMIT((((val) * 10 + 8)/16),0,255))
+#define IN_FROM_REG(val) (((val) * 16 + 5) / 10)
+
+static inline u8 FAN_TO_REG(long rpm, int div)
+{
+       if (rpm == 0)
+               return 255;
+       rpm = SENSORS_LIMIT(rpm, 1, 1000000);
+       return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1,
+                            254);
+}
+
+#define FAN_FROM_REG(val,div) ((val)==0?-1:(val)==255?0:1350000/((val)*(div)))
+
+#define TEMP_TO_REG(val) (SENSORS_LIMIT(((val)<0?(((val)-5)/10):\
+                                                 ((val)+5)/10),0,255))
+#define TEMP_FROM_REG(val) (((val)>0x80?(val)-0x100:(val))*10)
+
+#define AS99127_TEMP_ADD_TO_REG(val) (SENSORS_LIMIT((((((val) + 2)*4)/10) \
+                                               << 7),0,0xffff))
+#define AS99127_TEMP_ADD_FROM_REG(val) ((((val) >> 7) * 10) / 4)
+
+#define ALARMS_FROM_REG(val) (val)
+#define PWM_FROM_REG(val) (val)
+#define PWM_TO_REG(val) (SENSORS_LIMIT((val),0,255))
+#define BEEPS_FROM_REG(val,type) ((type)==as99127f?(val)^0x7FFF:(val))
+#define BEEPS_TO_REG(val,type) ((type)==as99127f?(~(val))&0x7FFF:(val)&0xffffff)
+
+#define BEEP_ENABLE_TO_REG(val)   ((val)?1:0)
+#define BEEP_ENABLE_FROM_REG(val) ((val)?1:0)
+
+#define DIV_FROM_REG(val) (1 << (val))
+
+static inline u8 DIV_TO_REG(long val, enum chips type)
+{
+       int i;
+       val = SENSORS_LIMIT(val, 1,
+               ((type == w83781d || type == as99127f) ? 8 : 128)) >> 1;
+       for (i = 0; i < 6; i++) {
+               if (val == 0)
+                       break;
+               val >>= 1;
+       }
+       return ((u8) i);
+}
+
+/* There are some complications in a module like this. First off, W83781D chips
+   may be both present on the SMBus and the ISA bus, and we have to handle
+   those cases separately at some places. Second, there might be several
+   W83781D chips available (well, actually, that is probably never done; but
+   it is a clean illustration of how to handle a case like that). Finally,
+   a specific chip may be attached to *both* ISA and SMBus, and we would
+   not like to detect it double. Fortunately, in the case of the W83781D at
+   least, a register tells us what SMBus address we are on, so that helps
+   a bit - except if there could be more than one SMBus. Groan. No solution
+   for this yet. */
+
+/* This module may seem overly long and complicated. In fact, it is not so
+   bad. Quite a lot of bookkeeping is done. A real driver can often cut
+   some corners. */
+
+/* For each registered W83781D, we need to keep some data in memory. That
+   data is pointed to by w83781d_list[NR]->data. The structure itself is
+   dynamically allocated, at the same time when a new w83781d client is
+   allocated. */
+struct w83781d_data {
+       struct i2c_client client;
+       struct semaphore lock;
+       int sysctl_id;
+       enum chips type;
+
+       struct semaphore update_lock;
+       char valid;             /* !=0 if following fields are valid */
+       unsigned long last_updated;     /* In jiffies */
+
+       struct i2c_client *lm75;        /* for secondary I2C addresses */
+       /* pointer to array of 2 subclients */
+
+       u8 in[10];              /* Register value - 8 & 9 for 782D and 791D only 10 for 791D */
+       u8 in_max[10];          /* Register value - 8 & 9 for 782D and 791D only 10 for 791D */
+       u8 in_min[10];          /* Register value - 8 & 9 for 782D and 791D only 10 for 791D */
+       u8 fan[5];              /* Register value - 4 & 5 for 791D only */
+       u8 fan_min[5];          /* Register value - 4 & 5 for 791D only */
+       u8 temp;
+       u8 temp_over;           /* Register value */
+       u8 temp_hyst;           /* Register value */
+       u16 temp_add[2];        /* Register value */
+       u16 temp_add_over[2];   /* Register value */
+       u16 temp_add_hyst[2];   /* Register value */
+       u8 fan_div[3];          /* Register encoding, shifted right */
+       u8 vid;                 /* Register encoding, combined */
+       u32 alarms;             /* Register encoding, combined */
+       u32 beeps;              /* Register encoding, combined */
+       u8 beep_enable;         /* Boolean */
+       u8 pwm[4];              /* Register value */
+       u8 pwmenable[4];        /* bool */
+       u16 sens[3];            /* 782D/783S only.
+                                  1 = pentium diode; 2 = 3904 diode;
+                                  3000-5000 = thermistor beta.
+                                  Default = 3435. 
+                                  Other Betas unimplemented */
+#ifdef W83781D_RT
+       u8 rt[3][32];           /* Register value */
+#endif
+       u8 vrm;
+};
+
+
+static int w83781d_attach_adapter(struct i2c_adapter *adapter);
+static int w83781d_detect(struct i2c_adapter *adapter, int address,
+                         unsigned short flags, int kind);
+static int w83781d_detach_client(struct i2c_client *client);
+
+static int w83781d_read_value(struct i2c_client *client, u16 register);
+static int w83781d_write_value(struct i2c_client *client, u16 register,
+                              u16 value);
+static void w83781d_update_client(struct i2c_client *client);
+static void w83781d_init_client(struct i2c_client *client);
+
+
+static void w83781d_in(struct i2c_client *client, int operation,
+                      int ctl_name, int *nrels_mag, long *results);
+static void w83781d_fan(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void w83781d_temp(struct i2c_client *client, int operation,
+                        int ctl_name, int *nrels_mag, long *results);
+static void w83781d_temp_add(struct i2c_client *client, int operation,
+                            int ctl_name, int *nrels_mag, long *results);
+static void w83781d_vid(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void w83781d_vrm(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void w83781d_alarms(struct i2c_client *client, int operation,
+                          int ctl_name, int *nrels_mag, long *results);
+static void w83781d_beep(struct i2c_client *client, int operation,
+                        int ctl_name, int *nrels_mag, long *results);
+static void w83781d_fan_div(struct i2c_client *client, int operation,
+                           int ctl_name, int *nrels_mag, long *results);
+static void w83781d_pwm(struct i2c_client *client, int operation,
+                       int ctl_name, int *nrels_mag, long *results);
+static void w83781d_sens(struct i2c_client *client, int operation,
+                        int ctl_name, int *nrels_mag, long *results);
+#ifdef W83781D_RT
+static void w83781d_rt(struct i2c_client *client, int operation,
+                      int ctl_name, int *nrels_mag, long *results);
+#endif
+
+static int w83781d_id = 0;
+
+static struct i2c_driver w83781d_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "W83781D sensor driver",
+       .id             = I2C_DRIVERID_W83781D,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = w83781d_attach_adapter,
+       .detach_client  = w83781d_detach_client,
+};
+
+/* The /proc/sys entries */
+/* -- SENSORS SYSCTL START -- */
+
+#define W83781D_SYSCTL_IN0 1000        /* Volts * 100 */
+#define W83781D_SYSCTL_IN1 1001
+#define W83781D_SYSCTL_IN2 1002
+#define W83781D_SYSCTL_IN3 1003
+#define W83781D_SYSCTL_IN4 1004
+#define W83781D_SYSCTL_IN5 1005
+#define W83781D_SYSCTL_IN6 1006
+#define W83781D_SYSCTL_IN7 1007
+#define W83781D_SYSCTL_IN8 1008
+#define W83781D_SYSCTL_IN9 1009
+#define W83781D_SYSCTL_FAN1 1101       /* Rotations/min */
+#define W83781D_SYSCTL_FAN2 1102
+#define W83781D_SYSCTL_FAN3 1103
+#define W83781D_SYSCTL_FAN4 1104
+#define W83781D_SYSCTL_FAN5 1105
+
+#define W83781D_SYSCTL_TEMP1 1200      /* Degrees Celcius * 10 */
+#define W83781D_SYSCTL_TEMP2 1201      /* Degrees Celcius * 10 */
+#define W83781D_SYSCTL_TEMP3 1202      /* Degrees Celcius * 10 */
+#define W83781D_SYSCTL_VID 1300                /* Volts * 1000 */
+#define W83781D_SYSCTL_VRM 1301
+#define W83781D_SYSCTL_PWM1 1401
+#define W83781D_SYSCTL_PWM2 1402
+#define W83781D_SYSCTL_PWM3 1403
+#define W83781D_SYSCTL_PWM4 1404
+#define W83781D_SYSCTL_SENS1 1501      /* 1, 2, or Beta (3000-5000) */
+#define W83781D_SYSCTL_SENS2 1502
+#define W83781D_SYSCTL_SENS3 1503
+#define W83781D_SYSCTL_RT1   1601      /* 32-entry table */
+#define W83781D_SYSCTL_RT2   1602      /* 32-entry table */
+#define W83781D_SYSCTL_RT3   1603      /* 32-entry table */
+#define W83781D_SYSCTL_FAN_DIV 2000    /* 1, 2, 4 or 8 */
+#define W83781D_SYSCTL_ALARMS 2001     /* bitvector */
+#define W83781D_SYSCTL_BEEP 2002       /* bitvector */
+
+#define W83781D_ALARM_IN0 0x0001
+#define W83781D_ALARM_IN1 0x0002
+#define W83781D_ALARM_IN2 0x0004
+#define W83781D_ALARM_IN3 0x0008
+#define W83781D_ALARM_IN4 0x0100
+#define W83781D_ALARM_IN5 0x0200
+#define W83781D_ALARM_IN6 0x0400
+#define W83782D_ALARM_IN7 0x10000
+#define W83782D_ALARM_IN8 0x20000
+#define W83781D_ALARM_FAN1 0x0040
+#define W83781D_ALARM_FAN2 0x0080
+#define W83781D_ALARM_FAN3 0x0800
+#define W83781D_ALARM_TEMP1 0x0010
+#define W83781D_ALARM_TEMP23 0x0020    /* 781D only */
+#define W83781D_ALARM_TEMP2 0x0020     /* 782D/783S */
+#define W83781D_ALARM_TEMP3 0x2000     /* 782D only */
+#define W83781D_ALARM_CHAS 0x1000
+
+/* -- SENSORS SYSCTL END -- */
+
+/* These files are created for each detected chip. This is just a template;
+   though at first sight, you might think we could use a statically
+   allocated list, we need some way to get back to the parent - which
+   is done through one of the 'extra' fields which are initialized 
+   when a new copy is allocated. */
+
+/* just a guess - no datasheet */
+static ctl_table as99127f_dir_table_template[] = {
+       {W83781D_SYSCTL_IN0, "in0", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN1, "in1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN2, "in2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN3, "in3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN4, "in4", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN5, "in5", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN6, "in6", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_fan},
+       {W83781D_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_fan},
+       {W83781D_SYSCTL_FAN3, "fan3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_fan},
+       {W83781D_SYSCTL_TEMP1, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_temp},
+       {W83781D_SYSCTL_TEMP2, "temp2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_temp_add},
+       {W83781D_SYSCTL_TEMP3, "temp3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_temp_add},
+       {W83781D_SYSCTL_VID, "vid", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_vid},
+       {W83781D_SYSCTL_VRM, "vrm", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_vrm},
+       {W83781D_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_fan_div},
+       {W83781D_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_alarms},
+       {W83781D_SYSCTL_BEEP, "beep", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_beep},
+       {0}
+};
+
+static ctl_table w83781d_dir_table_template[] = {
+       {W83781D_SYSCTL_IN0, "in0", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN1, "in1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN2, "in2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN3, "in3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN4, "in4", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN5, "in5", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN6, "in6", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_fan},
+       {W83781D_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_fan},
+       {W83781D_SYSCTL_FAN3, "fan3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_fan},
+       {W83781D_SYSCTL_TEMP1, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_temp},
+       {W83781D_SYSCTL_TEMP2, "temp2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_temp_add},
+       {W83781D_SYSCTL_TEMP3, "temp3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_temp_add},
+       {W83781D_SYSCTL_VID, "vid", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_vid},
+       {W83781D_SYSCTL_VRM, "vrm", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_vrm},
+       {W83781D_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_fan_div},
+       {W83781D_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_alarms},
+       {W83781D_SYSCTL_BEEP, "beep", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_beep},
+#ifdef W83781D_RT
+       {W83781D_SYSCTL_RT1, "rt1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_rt},
+       {W83781D_SYSCTL_RT2, "rt2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_rt},
+       {W83781D_SYSCTL_RT3, "rt3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_rt},
+#endif
+       {0}
+};
+
+/* without pwm3-4 */
+static ctl_table w83782d_isa_dir_table_template[] = {
+       {W83781D_SYSCTL_IN0, "in0", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN1, "in1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN2, "in2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN3, "in3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN4, "in4", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN5, "in5", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN6, "in6", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN7, "in7", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN8, "in8", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_fan},
+       {W83781D_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_fan},
+       {W83781D_SYSCTL_FAN3, "fan3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_fan},
+       {W83781D_SYSCTL_TEMP1, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_temp},
+       {W83781D_SYSCTL_TEMP2, "temp2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_temp_add},
+       {W83781D_SYSCTL_TEMP3, "temp3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_temp_add},
+       {W83781D_SYSCTL_VID, "vid", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_vid},
+       {W83781D_SYSCTL_VRM, "vrm", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_vrm},
+       {W83781D_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_fan_div},
+       {W83781D_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_alarms},
+       {W83781D_SYSCTL_BEEP, "beep", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_beep},
+       {W83781D_SYSCTL_PWM1, "pwm1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_pwm},
+       {W83781D_SYSCTL_PWM2, "pwm2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_pwm},
+       {W83781D_SYSCTL_SENS1, "sensor1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_sens},
+       {W83781D_SYSCTL_SENS2, "sensor2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_sens},
+       {W83781D_SYSCTL_SENS3, "sensor3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_sens},
+       {0}
+};
+
+/* with pwm3-4 */
+static ctl_table w83782d_i2c_dir_table_template[] = {
+       {W83781D_SYSCTL_IN0, "in0", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN1, "in1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN2, "in2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN3, "in3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN4, "in4", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN5, "in5", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN6, "in6", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN7, "in7", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN8, "in8", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_fan},
+       {W83781D_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_fan},
+       {W83781D_SYSCTL_FAN3, "fan3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_fan},
+       {W83781D_SYSCTL_TEMP1, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_temp},
+       {W83781D_SYSCTL_TEMP2, "temp2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_temp_add},
+       {W83781D_SYSCTL_TEMP3, "temp3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_temp_add},
+       {W83781D_SYSCTL_VID, "vid", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_vid},
+       {W83781D_SYSCTL_VRM, "vrm", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_vrm},
+       {W83781D_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_fan_div},
+       {W83781D_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_alarms},
+       {W83781D_SYSCTL_BEEP, "beep", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_beep},
+       {W83781D_SYSCTL_PWM1, "pwm1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_pwm},
+       {W83781D_SYSCTL_PWM2, "pwm2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_pwm},
+       {W83781D_SYSCTL_PWM3, "pwm3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_pwm},
+       {W83781D_SYSCTL_PWM4, "pwm4", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_pwm},
+       {W83781D_SYSCTL_SENS1, "sensor1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_sens},
+       {W83781D_SYSCTL_SENS2, "sensor2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_sens},
+       {W83781D_SYSCTL_SENS3, "sensor3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_sens},
+       {0}
+};
+
+/* w83791D has 10 voltages 5 fans and 3 temps.  2 of the temps are on other 
+ devices. */
+static ctl_table w83791d_dir_table_template[] = {
+       {W83781D_SYSCTL_IN0, "in0", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN1, "in1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN2, "in2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN3, "in3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN4, "in4", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN5, "in5", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN6, "in6", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN7, "in7", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN8, "in8", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN9, "in9", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_fan},
+       {W83781D_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_fan},
+       {W83781D_SYSCTL_FAN3, "fan3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_fan},
+       {W83781D_SYSCTL_FAN4, "fan4", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_fan},
+       {W83781D_SYSCTL_FAN5, "fan5", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_fan},
+       {W83781D_SYSCTL_TEMP1, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_temp},
+       {W83781D_SYSCTL_TEMP2, "temp2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_temp_add},
+       {W83781D_SYSCTL_TEMP3, "temp3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_temp_add},
+       {W83781D_SYSCTL_VID, "vid", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_vid},
+       {W83781D_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_fan_div},
+       {W83781D_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_alarms},
+       {W83781D_SYSCTL_BEEP, "beep", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_beep},
+       {W83781D_SYSCTL_PWM1, "pwm1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_pwm},
+       {W83781D_SYSCTL_PWM2, "pwm2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_pwm},
+       {W83781D_SYSCTL_PWM3, "pwm3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_pwm},
+       {W83781D_SYSCTL_PWM4, "pwm4", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_pwm},
+       {W83781D_SYSCTL_VRM, "vrm", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_vrm},
+       {0}
+};
+
+static ctl_table w83783s_dir_table_template[] = {
+       {W83781D_SYSCTL_IN0, "in0", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       /* no in1 to maintain compatibility with 781d and 782d. */
+       {W83781D_SYSCTL_IN2, "in2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN3, "in3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN4, "in4", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN5, "in5", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN6, "in6", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_fan},
+       {W83781D_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_fan},
+       {W83781D_SYSCTL_FAN3, "fan3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_fan},
+       {W83781D_SYSCTL_TEMP1, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_temp},
+       {W83781D_SYSCTL_TEMP2, "temp2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_temp_add},
+       {W83781D_SYSCTL_VID, "vid", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_vid},
+       {W83781D_SYSCTL_VRM, "vrm", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_vrm},
+       {W83781D_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_fan_div},
+       {W83781D_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_alarms},
+       {W83781D_SYSCTL_BEEP, "beep", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_beep},
+       {W83781D_SYSCTL_PWM1, "pwm1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_pwm},
+       {W83781D_SYSCTL_PWM2, "pwm2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_pwm},
+       {W83781D_SYSCTL_SENS1, "sensor1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_sens},
+       {W83781D_SYSCTL_SENS2, "sensor2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_sens},
+       {0}
+};
+
+/* similar to w83782d but no fan3, no vid */
+static ctl_table w83697hf_dir_table_template[] = {
+       {W83781D_SYSCTL_IN0, "in0", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       /* no in1 to maintain compatibility with 781d and 782d. */
+       {W83781D_SYSCTL_IN2, "in2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN3, "in3", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN4, "in4", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN5, "in5", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN6, "in6", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN7, "in7", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_IN8, "in8", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_in},
+       {W83781D_SYSCTL_FAN1, "fan1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_fan},
+       {W83781D_SYSCTL_FAN2, "fan2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_fan},
+       {W83781D_SYSCTL_TEMP1, "temp1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_temp},
+       {W83781D_SYSCTL_TEMP2, "temp2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_temp_add},
+       {W83781D_SYSCTL_FAN_DIV, "fan_div", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_fan_div},
+       {W83781D_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_alarms},
+       {W83781D_SYSCTL_BEEP, "beep", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_beep},
+       {W83781D_SYSCTL_PWM1, "pwm1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_pwm},
+       {W83781D_SYSCTL_PWM2, "pwm2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_pwm},
+       {W83781D_SYSCTL_SENS1, "sensor1", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_sens},
+       {W83781D_SYSCTL_SENS2, "sensor2", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &w83781d_sens},
+       {0}
+};
+
+
+/* This function is called when:
+     * w83781d_driver is inserted (when this module is loaded), for each
+       available adapter
+     * when a new adapter is inserted (and w83781d_driver is still present) */
+static int w83781d_attach_adapter(struct i2c_adapter *adapter)
+{
+       return i2c_detect(adapter, &addr_data, w83781d_detect);
+}
+
+static int w83781d_detect(struct i2c_adapter *adapter, int address,
+                  unsigned short flags, int kind)
+{
+       int i, val1 = 0, val2, id;
+       struct i2c_client *new_client;
+       struct w83781d_data *data;
+       int err = 0;
+       const char *type_name = "";
+       const char *client_name = "";
+       int is_isa = i2c_is_isa_adapter(adapter);
+       enum vendor { winbond, asus } vendid;
+
+       if (!is_isa
+           && !i2c_check_functionality(adapter,
+                                       I2C_FUNC_SMBUS_BYTE_DATA)) goto
+                   ERROR0;
+
+       if (is_isa) {
+               if (!request_region(address, W83781D_EXTENT, "w83781d"))
+                       goto ERROR0;
+               release_region(address, W83781D_EXTENT);
+       }
+
+       /* Probe whether there is anything available on this address. Already
+          done for SMBus clients */
+       if (kind < 0) {
+               if (is_isa) {
+
+#define REALLY_SLOW_IO
+                       /* We need the timeouts for at least some LM78-like chips. But only
+                          if we read 'undefined' registers. */
+                       i = inb_p(address + 1);
+                       if (inb_p(address + 2) != i)
+                               goto ERROR0;
+                       if (inb_p(address + 3) != i)
+                               goto ERROR0;
+                       if (inb_p(address + 7) != i)
+                               goto ERROR0;
+#undef REALLY_SLOW_IO
+
+                       /* Let's just hope nothing breaks here */
+                       i = inb_p(address + 5) & 0x7f;
+                       outb_p(~i & 0x7f, address + 5);
+                       if ((inb_p(address + 5) & 0x7f) != (~i & 0x7f)) {
+                               outb_p(i, address + 5);
+                               return 0;
+                       }
+               }
+       }
+
+       /* OK. For now, we presume we have a valid client. We now create the
+          client structure, even though we cannot fill it completely yet.
+          But it allows us to access w83781d_{read,write}_value. */
+
+       if (!(data = kmalloc(sizeof(struct w83781d_data), GFP_KERNEL))) {
+               err = -ENOMEM;
+               goto ERROR0;
+       }
+
+       new_client = &data->client;
+       new_client->addr = address;
+       init_MUTEX(&data->lock);
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &w83781d_driver;
+       new_client->flags = 0;
+
+       /* Now, we do the remaining detection. */
+
+       /* The w8378?d may be stuck in some other bank than bank 0. This may
+          make reading other information impossible. Specify a force=... or
+          force_*=... parameter, and the Winbond will be reset to the right
+          bank. */
+       if (kind < 0) {
+               if (w83781d_read_value(new_client, W83781D_REG_CONFIG) &
+                   0x80) {
+                       err = -ENODEV;
+                       goto ERROR1;
+               }
+               val1 = w83781d_read_value(new_client, W83781D_REG_BANK);
+               val2 = w83781d_read_value(new_client, W83781D_REG_CHIPMAN);
+               /* Check for Winbond or Asus ID if in bank 0 */
+               if ((!(val1 & 0x07)) &&
+                   (((!(val1 & 0x80)) && (val2 != 0xa3) && (val2 != 0xc3))
+                    || ((val1 & 0x80) && (val2 != 0x5c) && (val2 != 0x12)))) {
+                       err = -ENODEV;
+                       goto ERROR1;
+               }
+               /* If Winbond SMBus, check address at 0x48.
+                  Asus doesn't support, except for the as99127f rev.2 */
+               if ((!is_isa) && (((!(val1 & 0x80)) && (val2 == 0xa3)) ||
+                                 ((val1 & 0x80) && (val2 == 0x5c)))) {
+                       if (w83781d_read_value
+                           (new_client, W83781D_REG_I2C_ADDR) != address) {
+                               err = -ENODEV;
+                               goto ERROR1;
+                       }
+               }
+       }
+
+       /* We have either had a force parameter, or we have already detected the
+          Winbond. Put it now into bank 0 and Vendor ID High Byte */
+       w83781d_write_value(new_client, W83781D_REG_BANK,
+                           (w83781d_read_value(new_client,
+                                               W83781D_REG_BANK) & 0x78) |
+                           0x80);
+
+       /* Determine the chip type. */
+       if (kind <= 0) {
+               /* get vendor ID */
+               val2 = w83781d_read_value(new_client, W83781D_REG_CHIPMAN);
+               if (val2 == 0x5c)
+                       vendid = winbond;
+               else if (val2 == 0x12)
+                       vendid = asus;
+               else {
+                       err = -ENODEV;
+                       goto ERROR1;
+               }
+               val1 =
+                   w83781d_read_value(new_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 && !is_isa && address == 0x2d)
+                       kind = w83783s;
+               else if (val1 == 0x21 && vendid == winbond)
+                       kind = w83627hf;
+               else if (val1 == 0x71 && vendid == winbond && address >= 0x2c)
+                       kind = w83791d;
+               else if (val1 == 0x31 && !is_isa && address >= 0x28)
+                       kind = as99127f;
+               else if (val1 == 0x60 && vendid == winbond && is_isa)
+                       kind = w83697hf;
+               else {
+                       if (kind == 0)
+                               printk
+                                   (KERN_WARNING "w83781d.o: Ignoring 'force' parameter for unknown chip at"
+                                    "adapter %d, address 0x%02x\n",
+                                    i2c_adapter_id(adapter), address);
+                       err = -EINVAL;
+                       goto ERROR1;
+               }
+       }
+
+       if (kind == w83781d) {
+               type_name = "w83781d";
+               client_name = "W83781D chip";
+       } else if (kind == w83782d) {
+               type_name = "w83782d";
+               client_name = "W83782D chip";
+       } else if (kind == w83783s) {
+               type_name = "w83783s";
+               client_name = "W83783S chip";
+       } else if (kind == w83627hf) {
+               type_name = "w83627hf";
+               client_name = "W83627HF chip";
+       } else if (kind == as99127f) {
+               type_name = "as99127f";
+               client_name = "AS99127F chip";
+       } else if (kind == w83697hf) {
+               type_name = "w83697hf";
+               client_name = "W83697HF chip";
+        } else if (kind == w83791d) {
+               type_name = "w83791d";
+               client_name = "W83791D chip";
+       } else {
+#ifdef DEBUG
+               printk(KERN_ERR "w83781d.o: Internal error: unknown kind (%d)?!?",
+                      kind);
+#endif
+               err = -ENODEV;
+               goto ERROR1;
+       }
+
+       /* Reserve the ISA region */
+       if (is_isa)
+               request_region(address, W83781D_EXTENT, type_name);
+
+       /* Fill in the remaining client fields and put it into the global list */
+       strcpy(new_client->name, client_name);
+       data->type = kind;
+
+       new_client->id = w83781d_id++;
+       data->valid = 0;
+       init_MUTEX(&data->update_lock);
+
+       /* Tell the I2C layer a new client has arrived */
+       if ((err = i2c_attach_client(new_client)))
+               goto ERROR3;
+
+       /* attach secondary i2c lm75-like clients */
+       if (!is_isa) {
+               if (!(data->lm75 = kmalloc(2 * sizeof(struct i2c_client),
+                                          GFP_KERNEL))) {
+                       err = -ENOMEM;
+                       goto ERROR4;
+               }
+               id = i2c_adapter_id(adapter);
+               if(force_subclients[0] == id && force_subclients[1] == address) {
+                       for(i = 2; i <= 3; i++) {
+                               if(force_subclients[i] < 0x48 ||
+                                  force_subclients[i] > 0x4f) {
+                                       printk(KERN_ERR "w83781d.o: Invalid subclient address %d; must be 0x48-0x4f\n",
+                                               force_subclients[i]);
+                                       err = -EINVAL;
+                                       goto ERROR5;
+                               }
+                       }
+                       w83781d_write_value(new_client,
+                                           W83781D_REG_I2C_SUBADDR,
+                                           (force_subclients[2] & 0x07) |
+                                           ((force_subclients[3] & 0x07) <<4));
+                       data->lm75[0].addr = force_subclients[2];
+               } else {
+                       val1 = w83781d_read_value(new_client,
+                                                 W83781D_REG_I2C_SUBADDR);
+                       data->lm75[0].addr = 0x48 + (val1 & 0x07);
+               }
+               if (kind != w83783s) {
+                       if(force_subclients[0] == id &&
+                          force_subclients[1] == address) {
+                               data->lm75[1].addr = force_subclients[3];
+                       } else {
+                               data->lm75[1].addr = 0x48 + ((val1 >> 4) & 0x07);
+                       }
+                       if(data->lm75[0].addr == data->lm75[1].addr) {
+                               printk(KERN_ERR "w83781d.o: Duplicate addresses 0x%x for subclients.\n",
+                                       data->lm75[0].addr);
+                               err = -EBUSY;
+                               goto ERROR5;
+                       }
+               }
+               if (kind == w83781d)
+                       client_name = "W83781D subclient";
+               else if (kind == w83782d)
+                       client_name = "W83782D subclient";
+               else if (kind == w83783s)
+                       client_name = "W83783S subclient";
+               else if (kind == w83627hf)
+                       client_name = "W83627HF subclient";
+               else if (kind == as99127f)
+                       client_name = "AS99127F subclient";
+                else if (kind == w83791d)
+                       client_name = "W83791D subclient";
+
+
+               for (i = 0; i <= 1; i++) {
+                       data->lm75[i].data = NULL;      /* store all data in w83781d */
+                       data->lm75[i].adapter = adapter;
+                       data->lm75[i].driver = &w83781d_driver;
+                       data->lm75[i].flags = 0;
+                       strcpy(data->lm75[i].name, client_name);
+                       data->lm75[i].id = w83781d_id++;
+                       if ((err = i2c_attach_client(&(data->lm75[i])))) {
+                               printk(KERN_ERR "w83781d.o: Subclient %d registration at address 0x%x failed.\n",
+                                      i, data->lm75[i].addr);
+                               if (i == 1)
+                                       goto ERROR6;
+                               goto ERROR5;
+                       }
+                       if (kind == w83783s)
+                               break;
+               }
+       } else {
+               data->lm75 = NULL;
+       }
+
+       /* Register a new directory entry with module sensors */
+       if ((i = i2c_register_entry(new_client,
+                                       type_name,
+                                       (kind == as99127f) ?
+                                          as99127f_dir_table_template :
+                                       (kind == w83781d) ?
+                                          w83781d_dir_table_template :
+                                       (kind == w83783s) ?
+                                          w83783s_dir_table_template :
+                                       (kind == w83697hf) ?
+                                          w83697hf_dir_table_template :
+                                        (kind == w83791d ) ?
+                                            w83791d_dir_table_template :
+                                        (is_isa || kind == w83627hf) ?
+                                          w83782d_isa_dir_table_template :
+                                          w83782d_i2c_dir_table_template)) < 0) {
+               err = i;
+               goto ERROR7;
+       }
+       data->sysctl_id = i;
+
+       /* Only PWM2 can be disabled */
+       for(i = 0; i < 4; i++)
+               data->pwmenable[i] = 1;
+
+       /* Initialize the chip */
+       w83781d_init_client(new_client);
+       return 0;
+
+/* OK, this is not exactly good programming practice, usually. But it is
+   very code-efficient in this case. */
+
+      ERROR7:
+       if (!is_isa)
+               i2c_detach_client(&
+                                 (((struct
+                                    w83781d_data *) (new_client->data))->
+                                  lm75[1]));
+      ERROR6:
+       if (!is_isa)
+               i2c_detach_client(&
+                                 (((struct
+                                    w83781d_data *) (new_client->data))->
+                                  lm75[0]));
+      ERROR5:
+       if (!is_isa)
+               kfree(((struct w83781d_data *) (new_client->data))->lm75);
+      ERROR4:
+       i2c_detach_client(new_client);
+      ERROR3:
+       if (is_isa)
+               release_region(address, W83781D_EXTENT);
+      ERROR1:
+       kfree(data);
+      ERROR0:
+       return err;
+}
+
+static int w83781d_detach_client(struct i2c_client *client)
+{
+       int err;
+       struct w83781d_data *data = client->data;
+
+       i2c_deregister_entry(data->sysctl_id);
+
+       if ((err = i2c_detach_client(client))) {
+               printk
+                   (KERN_ERR "w83781d.o: Client deregistration failed, client not detached.\n");
+               return err;
+       }
+
+       if(i2c_is_isa_client(client)) {
+               release_region(client->addr, W83781D_EXTENT);
+       } else {
+               i2c_detach_client(&(data->lm75[0]));
+               if (data->type != w83783s)
+                       i2c_detach_client(&(data->lm75[1]));
+               kfree(data->lm75);
+       }
+       kfree(data);
+
+       return 0;
+}
+
+/* The SMBus locks itself, usually, but nothing may access the Winbond between
+   bank switches. ISA access must always be locked explicitly! 
+   We ignore the W83781D BUSY flag at this moment - it could lead to deadlocks,
+   would slow down the W83781D access and should not be necessary. 
+   There are some ugly typecasts here, but the good news is - they should
+   nowhere else be necessary! */
+static int w83781d_read_value(struct i2c_client *client, u16 reg)
+{
+       int res, word_sized, bank;
+       struct i2c_client *cl;
+
+       down(&(((struct w83781d_data *) (client->data))->lock));
+       if (i2c_is_isa_client(client)) {
+               word_sized = (((reg & 0xff00) == 0x100)
+                             || ((reg & 0xff00) == 0x200))
+                   && (((reg & 0x00ff) == 0x50)
+                       || ((reg & 0x00ff) == 0x53)
+                       || ((reg & 0x00ff) == 0x55));
+               if (reg & 0xff00) {
+                       outb_p(W83781D_REG_BANK,
+                              client->addr + W83781D_ADDR_REG_OFFSET);
+                       outb_p(reg >> 8,
+                              client->addr + W83781D_DATA_REG_OFFSET);
+               }
+               outb_p(reg & 0xff, client->addr + W83781D_ADDR_REG_OFFSET);
+               res = inb_p(client->addr + W83781D_DATA_REG_OFFSET);
+               if (word_sized) {
+                       outb_p((reg & 0xff) + 1,
+                              client->addr + W83781D_ADDR_REG_OFFSET);
+                       res =
+                           (res << 8) + inb_p(client->addr +
+                                              W83781D_DATA_REG_OFFSET);
+               }
+               if (reg & 0xff00) {
+                       outb_p(W83781D_REG_BANK,
+                              client->addr + W83781D_ADDR_REG_OFFSET);
+                       outb_p(0, client->addr + W83781D_DATA_REG_OFFSET);
+               }
+       } else {
+               bank = (reg >> 8) & 0x0f;
+               if (bank > 2)
+                       /* switch banks */
+                       i2c_smbus_write_byte_data(client, W83781D_REG_BANK,
+                                                 bank);
+               if (bank == 0 || bank > 2) {
+                       res = i2c_smbus_read_byte_data(client, reg & 0xff);
+               } else {
+                       /* switch to subclient */
+                       cl =
+                           &(((struct w83781d_data *) (client->data))->
+                             lm75[bank - 1]);
+                       /* convert from ISA to LM75 I2C addresses */
+                       switch (reg & 0xff) {
+                       case 0x50: /* TEMP */
+                               res = swab16(i2c_smbus_read_word_data(cl, 0));
+                               break;
+                       case 0x52: /* CONFIG */
+                               res = i2c_smbus_read_byte_data(cl, 1);
+                               break;
+                       case 0x53: /* HYST */
+                               res = swab16(i2c_smbus_read_word_data(cl, 2));
+                               break;
+                       case 0x55: /* OVER */
+                       default:
+                               res = swab16(i2c_smbus_read_word_data(cl, 3));
+                               break;
+                       }
+               }
+               if (bank > 2)
+                       i2c_smbus_write_byte_data(client, W83781D_REG_BANK,
+                                                 0);
+       }
+       up(&(((struct w83781d_data *) (client->data))->lock));
+       return res;
+}
+
+static int w83781d_write_value(struct i2c_client *client, u16 reg, u16 value)
+{
+       int word_sized, bank;
+       struct i2c_client *cl;
+
+       down(&(((struct w83781d_data *) (client->data))->lock));
+       if (i2c_is_isa_client(client)) {
+               word_sized = (((reg & 0xff00) == 0x100)
+                             || ((reg & 0xff00) == 0x200))
+                   && (((reg & 0x00ff) == 0x53)
+                       || ((reg & 0x00ff) == 0x55));
+               if (reg & 0xff00) {
+                       outb_p(W83781D_REG_BANK,
+                              client->addr + W83781D_ADDR_REG_OFFSET);
+                       outb_p(reg >> 8,
+                              client->addr + W83781D_DATA_REG_OFFSET);
+               }
+               outb_p(reg & 0xff, client->addr + W83781D_ADDR_REG_OFFSET);
+               if (word_sized) {
+                       outb_p(value >> 8,
+                              client->addr + W83781D_DATA_REG_OFFSET);
+                       outb_p((reg & 0xff) + 1,
+                              client->addr + W83781D_ADDR_REG_OFFSET);
+               }
+               outb_p(value & 0xff,
+                      client->addr + W83781D_DATA_REG_OFFSET);
+               if (reg & 0xff00) {
+                       outb_p(W83781D_REG_BANK,
+                              client->addr + W83781D_ADDR_REG_OFFSET);
+                       outb_p(0, client->addr + W83781D_DATA_REG_OFFSET);
+               }
+       } else {
+               bank = (reg >> 8) & 0x0f;
+               if (bank > 2)
+                       /* switch banks */
+                       i2c_smbus_write_byte_data(client, W83781D_REG_BANK,
+                                                 bank);
+               if (bank == 0 || bank > 2) {
+                       i2c_smbus_write_byte_data(client, reg & 0xff,
+                                                 value & 0xff);
+               } else {
+                       /* switch to subclient */
+                       cl = &(((struct w83781d_data *) (client->data))->
+                             lm75[bank - 1]);
+                       /* convert from ISA to LM75 I2C addresses */
+                       switch (reg & 0xff) {
+                       case 0x52: /* CONFIG */
+                               i2c_smbus_write_byte_data(cl, 1, value & 0xff);
+                               break;
+                       case 0x53: /* HYST */
+                               i2c_smbus_write_word_data(cl, 2, swab16(value));
+                               break;
+                       case 0x55: /* OVER */
+                               i2c_smbus_write_word_data(cl, 3, swab16(value));
+                               break;
+                       }
+               }
+               if (bank > 2)
+                       i2c_smbus_write_byte_data(client, W83781D_REG_BANK,
+                                                 0);
+       }
+       up(&(((struct w83781d_data *) (client->data))->lock));
+       return 0;
+}
+
+/* Called when we have found a new W83781D. It should set limits, etc. */
+static void w83781d_init_client(struct i2c_client *client)
+{
+       struct w83781d_data *data = client->data;
+       int i, p;
+       int type = data->type;
+       u8 tmp;
+
+       if(init && type != as99127f) { /* this resets registers we don't have
+                                         documentation for on the as99127f */
+               /* save these registers */
+               i = w83781d_read_value(client, W83781D_REG_BEEP_CONFIG);
+               p = w83781d_read_value(client, W83781D_REG_PWMCLK12);
+               /* Reset all except Watchdog values and last conversion values
+                  This sets fan-divs to 2, among others */
+               w83781d_write_value(client, W83781D_REG_CONFIG, 0x80);
+               /* Restore the registers and disable power-on abnormal beep.
+                  This saves FAN 1/2/3 input/output values set by BIOS. */
+               w83781d_write_value(client, W83781D_REG_BEEP_CONFIG, i | 0x80);
+               w83781d_write_value(client, W83781D_REG_PWMCLK12, p);
+               /* Disable master beep-enable (reset turns it on).
+                  Individual beeps should be reset to off but for some reason
+                  disabling this bit helps some people not get beeped */
+               w83781d_write_value(client, W83781D_REG_BEEP_INTS2, 0);
+       }
+
+       data->vrm = (type == w83791d) ? 90 : 82;
+
+       if ((type != w83781d) && (type != as99127f)) {
+               tmp = w83781d_read_value(client, W83781D_REG_SCFG1);
+               for (i = 1; i <= 3; i++) {
+                       if (!(tmp & BIT_SCFG1[i - 1])) {
+                               data->sens[i - 1] = W83781D_DEFAULT_BETA;
+                       } else {
+                               if (w83781d_read_value
+                                   (client,
+                                    W83781D_REG_SCFG2) & BIT_SCFG2[i - 1])
+                                       data->sens[i - 1] = 1;
+                               else
+                                       data->sens[i - 1] = 2;
+                       }
+                       if ((type == w83783s || type == w83697hf) && (i == 2))
+                               break;
+               }
+       }
+#ifdef W83781D_RT
+/*
+   Fill up the RT Tables.
+   We assume that they are 32 bytes long, in order for temp 1-3.
+   Data sheet documentation is sparse.
+   We also assume that it is only for the 781D although I suspect
+   that the others support it as well....
+*/
+
+       if (init && type == w83781d) {
+               u16 k = 0;
+/*
+    Auto-indexing doesn't seem to work...
+    w83781d_write_value(client,W83781D_REG_RT_IDX,0);
+*/
+               for (i = 0; i < 3; i++) {
+                       int j;
+                       for (j = 0; j < 32; j++) {
+                               w83781d_write_value(client,
+                                                   W83781D_REG_RT_IDX,
+                                                   k++);
+                               data->rt[i][j] =
+                                   w83781d_read_value(client,
+                                                      W83781D_REG_RT_VAL);
+                       }
+               }
+       }
+#endif                         /* W83781D_RT */
+
+       if(init) {
+               w83781d_write_value(client, W83781D_REG_TEMP2_CONFIG, 0x00);
+               if (type != w83783s && type != w83697hf) {
+                       w83781d_write_value(client, W83781D_REG_TEMP3_CONFIG,
+                                           0x00);
+               }
+               if (type != w83781d) {
+                       /* enable comparator mode for temp2 and temp3 so
+                          alarm indication will work correctly */
+                       i = w83781d_read_value(client, W83781D_REG_IRQ);
+                       if (!(i & 0x40))
+                               w83781d_write_value(client, W83781D_REG_IRQ,
+                                                   i | 0x40);
+               }
+       }
+
+       /* Start monitoring */
+       w83781d_write_value(client, W83781D_REG_CONFIG,
+                           (w83781d_read_value(client,
+                                               W83781D_REG_CONFIG) & 0xf7)
+                           | 0x01);
+}
+
+static void w83781d_update_client(struct i2c_client *client)
+{
+       struct w83781d_data *data = client->data;
+       int i;
+
+       down(&data->update_lock);
+
+       if (time_after(jiffies - data->last_updated, HZ + HZ / 2) ||
+           time_before(jiffies, data->last_updated) || !data->valid) {
+               pr_debug(KERN_DEBUG "Starting device update\n");
+
+               for (i = 0; i <= 9; i++) {
+                       if ((data->type == w83783s || data->type == w83697hf)
+                           && (i == 1))
+                               continue;       /* 783S has no in1 */
+                       if (data->type == w83791d) {
+                                data->in[i] =
+                                        w83781d_read_value(client, W83791D_REG_IN(i));
+                                data->in_min[i] =
+                                        w83781d_read_value(client,
+                                                           W83791D_REG_IN_MIN(i));
+                                data->in_max[i] =
+                                        w83781d_read_value(client,
+                                                           W83791D_REG_IN_MAX(i));
+                       } else {
+                       data->in[i] =
+                           w83781d_read_value(client, W83781D_REG_IN(i));
+                       data->in_min[i] =
+                           w83781d_read_value(client,
+                                              W83781D_REG_IN_MIN(i));
+                       data->in_max[i] =
+                           w83781d_read_value(client,
+                                              W83781D_REG_IN_MAX(i));
+                       }
+                       if ((data->type != w83782d) && (data->type != w83697hf)
+                           && (data->type != w83627hf) && (i == 6)
+                           && (data->type != w83791d))
+                               break;
+
+                       if (data->type != w83791d && i == 8) 
+                         break;
+               }
+               for (i = 1; i <= 5; i++) {
+                       data->fan[i - 1] =
+                           w83781d_read_value(client, W83781D_REG_FAN(i));
+                       data->fan_min[i - 1] =
+                           w83781d_read_value(client,
+                                              W83781D_REG_FAN_MIN(i));
+                       if (data->type != w83791d && i == 3) break;
+               }
+               if (data->type != w83781d && data->type != as99127f) {
+                       for (i = 1; i <= 4; i++) {
+                               data->pwm[i - 1] =
+                                   w83781d_read_value(client,
+                                            W83781D_REG_PWM(data->type, i));
+                               if (((data->type == w83783s)
+                                    || (data->type == w83627hf)
+                                    || (data->type == w83697hf)
+                                    || ((data->type == w83782d)
+                                       && i2c_is_isa_client(client)))
+                                   && i == 2)
+                                       break;
+                       }
+                       /* Only PWM2 can be disabled */
+                       data->pwmenable[1] = (w83781d_read_value(client,
+                                             W83781D_REG_PWMCLK12) & 0x08) >> 3;
+               }
+
+               data->temp = w83781d_read_value(client, W83781D_REG_TEMP);
+               data->temp_over =
+                   w83781d_read_value(client, W83781D_REG_TEMP_OVER);
+               data->temp_hyst =
+                   w83781d_read_value(client, W83781D_REG_TEMP_HYST);
+               data->temp_add[0] =
+                   w83781d_read_value(client, W83781D_REG_TEMP2);
+               data->temp_add_over[0] =
+                   w83781d_read_value(client, W83781D_REG_TEMP2_OVER);
+               data->temp_add_hyst[0] =
+                   w83781d_read_value(client, W83781D_REG_TEMP2_HYST);
+               if (data->type != w83783s && data->type != w83697hf) {
+                       data->temp_add[1] =
+                           w83781d_read_value(client, W83781D_REG_TEMP3);
+                       data->temp_add_over[1] =
+                           w83781d_read_value(client, W83781D_REG_TEMP3_OVER);
+                       data->temp_add_hyst[1] =
+                           w83781d_read_value(client, W83781D_REG_TEMP3_HYST);
+               }
+               i = w83781d_read_value(client, W83781D_REG_VID_FANDIV);
+               if (data->type != w83697hf) {
+                       data->vid = i & 0x0f;
+                       data->vid |=
+                           (w83781d_read_value(client, W83781D_REG_CHIPID) & 0x01)
+                           << 4;
+               }
+               data->fan_div[0] = (i >> 4) & 0x03;
+               data->fan_div[1] = (i >> 6) & 0x03;
+               if (data->type != w83697hf) {
+                       data->fan_div[2] = (w83781d_read_value(client,
+                                              W83781D_REG_PIN) >> 6) & 0x03;
+               }
+               if ((data->type != w83781d) && (data->type != as99127f)) {
+                       i = w83781d_read_value(client, W83781D_REG_VBAT);
+                       data->fan_div[0] |= (i >> 3) & 0x04;
+                       data->fan_div[1] |= (i >> 4) & 0x04;
+                       if (data->type != w83697hf)
+                               data->fan_div[2] |= (i >> 5) & 0x04;
+               }
+               data->alarms =
+                   w83781d_read_value(client,
+                                      W83781D_REG_ALARM1) +
+                   (w83781d_read_value(client, W83781D_REG_ALARM2) << 8);
+               if ((data->type == w83782d) || (data->type == w83627hf) ||
+                  (data->type == w83697hf)) {
+                       data->alarms |=
+                           w83781d_read_value(client,
+                                              W83781D_REG_ALARM3) << 16;
+               }
+               i = w83781d_read_value(client, W83781D_REG_BEEP_INTS2);
+               data->beep_enable = i >> 7;
+               data->beeps = ((i & 0x7f) << 8) +
+                   w83781d_read_value(client, W83781D_REG_BEEP_INTS1);
+               if ((data->type != w83781d) && (data->type != as99127f)
+                   && (data->type != w83791d)) {
+                       data->beeps |=
+                           w83781d_read_value(client,
+                                              W83781D_REG_BEEP_INTS3) << 16;
+               }
+               data->last_updated = jiffies;
+               data->valid = 1;
+       }
+
+       up(&data->update_lock);
+}
+
+
+/* The next few functions are the call-back functions of the /proc/sys and
+   sysctl files. Which function is used is defined in the ctl_table in
+   the extra1 field.
+   Each function must return the magnitude (power of 10 to divide the date
+   with) if it is called with operation==SENSORS_PROC_REAL_INFO. It must
+   put a maximum of *nrels elements in results reflecting the data of this
+   file, and set *nrels to the number it actually put in it, if operation==
+   SENSORS_PROC_REAL_READ. Finally, it must get upto *nrels elements from
+   results and write them to the chip, if operations==SENSORS_PROC_REAL_WRITE.
+   Note that on SENSORS_PROC_REAL_READ, I do not check whether results is
+   large enough (by checking the incoming value of *nrels). This is not very
+   good practice, but as long as you put less than about 5 values in results,
+   you can assume it is large enough. */
+static void w83781d_in(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       struct w83781d_data *data = client->data;
+       int nr = ctl_name - W83781D_SYSCTL_IN0;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 2;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               w83781d_update_client(client);
+               results[0] = IN_FROM_REG(data->in_min[nr]);
+               results[1] = IN_FROM_REG(data->in_max[nr]);
+               results[2] = IN_FROM_REG(data->in[nr]);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->in_min[nr] = IN_TO_REG(results[0]);
+                       w83781d_write_value(client, W83781D_REG_IN_MIN(nr),
+                                           data->in_min[nr]);
+               }
+               if (*nrels_mag >= 2) {
+                       data->in_max[nr] = IN_TO_REG(results[1]);
+                       w83781d_write_value(client, W83781D_REG_IN_MAX(nr),
+                                           data->in_max[nr]);
+               }
+       }
+}
+
+void w83781d_fan(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct w83781d_data *data = client->data;
+       int nr = ctl_name - W83781D_SYSCTL_FAN1 + 1;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               w83781d_update_client(client);
+               results[0] = FAN_FROM_REG(data->fan_min[nr - 1],
+                                 DIV_FROM_REG(data->fan_div[nr - 1]));
+               results[1] = FAN_FROM_REG(data->fan[nr - 1],
+                                 DIV_FROM_REG(data->fan_div[nr - 1]));
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->fan_min[nr - 1] =
+                            FAN_TO_REG(results[0],
+                                   DIV_FROM_REG(data->fan_div[nr-1]));
+                       w83781d_write_value(client,
+                                           W83781D_REG_FAN_MIN(nr),
+                                           data->fan_min[nr - 1]);
+               }
+       }
+}
+
+void w83781d_temp(struct i2c_client *client, int operation, int ctl_name,
+                 int *nrels_mag, long *results)
+{
+       struct w83781d_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               w83781d_update_client(client);
+               results[0] = TEMP_FROM_REG(data->temp_over);
+               results[1] = TEMP_FROM_REG(data->temp_hyst);
+               results[2] = TEMP_FROM_REG(data->temp);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->temp_over = TEMP_TO_REG(results[0]);
+                       w83781d_write_value(client, W83781D_REG_TEMP_OVER,
+                                           data->temp_over);
+               }
+               if (*nrels_mag >= 2) {
+                       data->temp_hyst = TEMP_TO_REG(results[1]);
+                       w83781d_write_value(client, W83781D_REG_TEMP_HYST,
+                                           data->temp_hyst);
+               }
+       }
+}
+
+void w83781d_temp_add(struct i2c_client *client, int operation,
+                     int ctl_name, int *nrels_mag, long *results)
+{
+       struct w83781d_data *data = client->data;
+       int nr = ctl_name - W83781D_SYSCTL_TEMP2;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               w83781d_update_client(client);
+               if (data->type == as99127f) {
+                       results[0] =
+                           AS99127_TEMP_ADD_FROM_REG(data->
+                                                     temp_add_over[nr]);
+                       results[1] =
+                           AS99127_TEMP_ADD_FROM_REG(data->
+                                                     temp_add_hyst[nr]);
+                       results[2] =
+                           AS99127_TEMP_ADD_FROM_REG(data->temp_add[nr]);
+               } else {
+                       results[0] =
+                           LM75_TEMP_FROM_REG(data->temp_add_over[nr]);
+                       results[1] =
+                           LM75_TEMP_FROM_REG(data->temp_add_hyst[nr]);
+                       results[2] = LM75_TEMP_FROM_REG(data->temp_add[nr]);
+               }
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       if (data->type == as99127f)
+                               data->temp_add_over[nr] =
+                                   AS99127_TEMP_ADD_TO_REG(results[0]);
+                       else
+                               data->temp_add_over[nr] =
+                                   LM75_TEMP_TO_REG(results[0]);
+                       w83781d_write_value(client,
+                                           nr ? W83781D_REG_TEMP3_OVER :
+                                           W83781D_REG_TEMP2_OVER,
+                                           data->temp_add_over[nr]);
+               }
+               if (*nrels_mag >= 2) {
+                       if (data->type == as99127f)
+                               data->temp_add_hyst[nr] =
+                                   AS99127_TEMP_ADD_TO_REG(results[1]);
+                       else
+                               data->temp_add_hyst[nr] =
+                                   LM75_TEMP_TO_REG(results[1]);
+                       w83781d_write_value(client,
+                                           nr ? W83781D_REG_TEMP3_HYST :
+                                           W83781D_REG_TEMP2_HYST,
+                                           data->temp_add_hyst[nr]);
+               }
+       }
+}
+
+
+void w83781d_vid(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct w83781d_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 3;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               w83781d_update_client(client);
+               results[0] = vid_from_reg(data->vid, data->vrm);
+               *nrels_mag = 1;
+       }
+}
+
+void w83781d_vrm(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct w83781d_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 1;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               results[0] = data->vrm;
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1)
+                       data->vrm = results[0];
+       }
+}
+
+void w83781d_alarms(struct i2c_client *client, int operation, int ctl_name,
+                   int *nrels_mag, long *results)
+{
+       struct w83781d_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               w83781d_update_client(client);
+               results[0] = ALARMS_FROM_REG(data->alarms);
+               *nrels_mag = 1;
+       }
+}
+
+void w83781d_beep(struct i2c_client *client, int operation, int ctl_name,
+                 int *nrels_mag, long *results)
+{
+       struct w83781d_data *data = client->data;
+       int val;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               w83781d_update_client(client);
+               results[0] = BEEP_ENABLE_FROM_REG(data->beep_enable);
+               results[1] = BEEPS_FROM_REG(data->beeps, data->type);
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 2) {
+                       data->beeps = BEEPS_TO_REG(results[1], data->type);
+                       w83781d_write_value(client, W83781D_REG_BEEP_INTS1,
+                                           data->beeps & 0xff);
+                       if ((data->type != w83781d) &&
+                           (data->type != as99127f)) {
+                               w83781d_write_value(client,
+                                                   W83781D_REG_BEEP_INTS3,
+                                                   ((data-> beeps) >> 16) &
+                                                     0xff);
+                       }
+                       val = (data->beeps >> 8) & 0x7f;
+               } else if (*nrels_mag >= 1)
+                       val =
+                           w83781d_read_value(client,
+                                              W83781D_REG_BEEP_INTS2) &
+                           0x7f;
+               if (*nrels_mag >= 1) {
+                       data->beep_enable = BEEP_ENABLE_TO_REG(results[0]);
+                       w83781d_write_value(client, W83781D_REG_BEEP_INTS2,
+                                           val | data->beep_enable << 7);
+               }
+       }
+}
+
+/* w83697hf only has two fans */
+void w83781d_fan_div(struct i2c_client *client, int operation,
+                    int ctl_name, int *nrels_mag, long *results)
+{
+       struct w83781d_data *data = client->data;
+       int old, old2, old3 = 0;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               w83781d_update_client(client);
+               results[0] = DIV_FROM_REG(data->fan_div[0]);
+               results[1] = DIV_FROM_REG(data->fan_div[1]);
+               if (data->type == w83697hf) {
+                       *nrels_mag = 2;
+               } else {
+                       results[2] = DIV_FROM_REG(data->fan_div[2]);
+                       *nrels_mag = 3;
+               }
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               old = w83781d_read_value(client, W83781D_REG_VID_FANDIV);
+               /* w83781d and as99127f don't have extended divisor bits */
+               if ((data->type != w83781d) && data->type != as99127f) {
+                       old3 =
+                           w83781d_read_value(client, W83781D_REG_VBAT);
+               }
+               if (*nrels_mag >= 3 && data->type != w83697hf) {
+                       data->fan_div[2] =
+                           DIV_TO_REG(results[2], data->type);
+                       old2 = w83781d_read_value(client, W83781D_REG_PIN);
+                       old2 =
+                           (old2 & 0x3f) | ((data->fan_div[2] & 0x03) << 6);
+                       w83781d_write_value(client, W83781D_REG_PIN, old2);
+                       if ((data->type != w83781d) &&
+                           (data->type != as99127f)) {
+                               old3 =
+                                   (old3 & 0x7f) |
+                                   ((data->fan_div[2] & 0x04) << 5);
+                       }
+               }
+               if (*nrels_mag >= 2) {
+                       data->fan_div[1] =
+                           DIV_TO_REG(results[1], data->type);
+                       old =
+                           (old & 0x3f) | ((data->fan_div[1] & 0x03) << 6);
+                       if ((data->type != w83781d) &&
+                           (data->type != as99127f)) {
+                               old3 =
+                                   (old3 & 0xbf) |
+                                   ((data->fan_div[1] & 0x04) << 4);
+                       }
+               }
+               if (*nrels_mag >= 1) {
+                       data->fan_div[0] =
+                           DIV_TO_REG(results[0], data->type);
+                       old =
+                           (old & 0xcf) | ((data->fan_div[0] & 0x03) << 4);
+                       w83781d_write_value(client, W83781D_REG_VID_FANDIV,
+                                           old);
+                       if ((data->type != w83781d) &&
+                           (data->type != as99127f)) {
+                               old3 =
+                                   (old3 & 0xdf) |
+                                   ((data->fan_div[0] & 0x04) << 3);
+                               w83781d_write_value(client,
+                                                   W83781D_REG_VBAT,
+                                                   old3);
+                       }
+               }
+       }
+}
+
+void w83781d_pwm(struct i2c_client *client, int operation, int ctl_name,
+                int *nrels_mag, long *results)
+{
+       struct w83781d_data *data = client->data;
+       int nr = 1 + ctl_name - W83781D_SYSCTL_PWM1;
+       int j, k;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               w83781d_update_client(client);
+               results[0] = PWM_FROM_REG(data->pwm[nr - 1]);
+               results[1] = data->pwmenable[nr - 1];
+               *nrels_mag = 2;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->pwm[nr - 1] = PWM_TO_REG(results[0]);
+                       w83781d_write_value(client,
+                                           W83781D_REG_PWM(data->type, nr),
+                                           data->pwm[nr - 1]);
+               }
+               /* only PWM2 can be enabled/disabled */
+               if (*nrels_mag >= 2 && nr == 2) {
+                       j = w83781d_read_value(client, W83781D_REG_PWMCLK12);
+                       k = w83781d_read_value(client, W83781D_REG_BEEP_CONFIG);
+                       if(results[1]) {
+                               if(!(j & 0x08))
+                                       w83781d_write_value(client,
+                                            W83781D_REG_PWMCLK12, j | 0x08);
+                               if(k & 0x10)
+                                       w83781d_write_value(client,
+                                            W83781D_REG_BEEP_CONFIG, k & 0xef);
+                               data->pwmenable[1] = 1;
+                       } else {
+                               if(j & 0x08)
+                                       w83781d_write_value(client,
+                                            W83781D_REG_PWMCLK12, j & 0xf7);
+                               if(!(k & 0x10))
+                                       w83781d_write_value(client,
+                                            W83781D_REG_BEEP_CONFIG, j | 0x10);
+                               data->pwmenable[1] = 0;
+                       }
+               }
+       }
+}
+
+void w83781d_sens(struct i2c_client *client, int operation, int ctl_name,
+                 int *nrels_mag, long *results)
+{
+       struct w83781d_data *data = client->data;
+       int nr = 1 + ctl_name - W83781D_SYSCTL_SENS1;
+       u8 tmp;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               results[0] = data->sens[nr - 1];
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       switch (results[0]) {
+                       case 1: /* PII/Celeron diode */
+                               tmp = w83781d_read_value(client,
+                                                      W83781D_REG_SCFG1);
+                               w83781d_write_value(client,
+                                                   W83781D_REG_SCFG1,
+                                                   tmp | BIT_SCFG1[nr -
+                                                                   1]);
+                               tmp = w83781d_read_value(client,
+                                                      W83781D_REG_SCFG2);
+                               w83781d_write_value(client,
+                                                   W83781D_REG_SCFG2,
+                                                   tmp | BIT_SCFG2[nr -
+                                                                   1]);
+                               data->sens[nr - 1] = results[0];
+                               break;
+                       case 2: /* 3904 */
+                               tmp = w83781d_read_value(client,
+                                                      W83781D_REG_SCFG1);
+                               w83781d_write_value(client,
+                                                   W83781D_REG_SCFG1,
+                                                   tmp | BIT_SCFG1[nr -
+                                                                   1]);
+                               tmp = w83781d_read_value(client,
+                                                      W83781D_REG_SCFG2);
+                               w83781d_write_value(client,
+                                                   W83781D_REG_SCFG2,
+                                                   tmp & ~BIT_SCFG2[nr -
+                                                                    1]);
+                               data->sens[nr - 1] = results[0];
+                               break;
+                       case W83781D_DEFAULT_BETA:      /* thermistor */
+                               tmp = w83781d_read_value(client,
+                                                      W83781D_REG_SCFG1);
+                               w83781d_write_value(client,
+                                                   W83781D_REG_SCFG1,
+                                                   tmp & ~BIT_SCFG1[nr -
+                                                                    1]);
+                               data->sens[nr - 1] = results[0];
+                               break;
+                       default:
+                               printk
+                                   (KERN_ERR "w83781d.o: Invalid sensor type %ld; must be 1, 2, or %d\n",
+                                    results[0], W83781D_DEFAULT_BETA);
+                               break;
+                       }
+               }
+       }
+}
+
+#ifdef W83781D_RT
+static void w83781d_rt(struct i2c_client *client, int operation, int ctl_name,
+               int *nrels_mag, long *results)
+{
+       struct w83781d_data *data = client->data;
+       int nr = 1 + ctl_name - W83781D_SYSCTL_RT1;
+       int i;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               for (i = 0; i < 32; i++) {
+                       results[i] = data->rt[nr - 1][i];
+               }
+               *nrels_mag = 32;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag > 32)
+                       *nrels_mag = 32;
+               for (i = 0; i < *nrels_mag; i++) {
+                       /* fixme: no bounds checking 0-255 */
+                       data->rt[nr - 1][i] = results[i];
+                       w83781d_write_value(client, W83781D_REG_RT_IDX, i);
+                       w83781d_write_value(client, W83781D_REG_RT_VAL,
+                                           data->rt[nr - 1][i]);
+               }
+       }
+}
+#endif
+
+static int __init sm_w83781d_init(void)
+{
+       printk(KERN_INFO "w83781d.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       return i2c_add_driver(&w83781d_driver);
+}
+
+static void __exit sm_w83781d_exit(void)
+{
+       i2c_del_driver(&w83781d_driver);
+}
+
+
+
+MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>, "
+             "Philip Edelbrock <phil@netroedge.com>, "
+             "and Mark Studebaker <mdsxyz123@yahoo.com>");
+MODULE_DESCRIPTION("W83781D driver");
+MODULE_LICENSE("GPL");
+
+module_init(sm_w83781d_init);
+module_exit(sm_w83781d_exit);
--- linux-old/drivers/sensors/w83l785ts.c       Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/w83l785ts.c   Mon Dec 13 20:18:54 2004
@@ -0,0 +1,388 @@
+/*
+ * w83l785ts.c - Part of lm_sensors, Linux kernel modules for hardware
+ *               monitoring
+ * Copyright (C) 2003-2004  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
+ * resolution and a 3 deg accuracy. Data sheet can be obtained from
+ * Winbond's website at:
+ *   http://www.winbond-usa.com/products/winbond_products/pdfs/PCIC/W83L785TS-S.pdf
+ *
+ * Thanks to James Bolt <james@evilpenguin.com> for benchmarking the read
+ * error handling mechanism.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+#ifndef I2C_DRIVERID_W83L785TS
+#define I2C_DRIVERID_W83L785TS 1047
+#endif
+
+/* How many retries on register read error */
+#define MAX_RETRIES    5
+
+/*
+ * Address to scan
+ * Address is fully defined internally and cannot be changed.
+ */
+
+static unsigned short normal_i2c[] = { 0x2e, SENSORS_I2C_END };
+static unsigned short normal_i2c_range[] = { SENSORS_I2C_END };
+static unsigned int normal_isa[] = { SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+/*
+ * Insmod parameters
+ */
+
+SENSORS_INSMOD_1(w83l785ts);
+
+/*
+ * The W83L785TS-S registers
+ * Manufacturer ID is 0x5CA3 for Winbond.
+ */
+
+#define W83L785TS_REG_MAN_ID1          0x4D
+#define W83L785TS_REG_MAN_ID2          0x4C
+#define W83L785TS_REG_CHIP_ID          0x4E
+#define W83L785TS_REG_CONFIG           0x40
+#define W83L785TS_REG_TYPE             0x52
+#define W83L785TS_REG_TEMP             0x27
+#define W83L785TS_REG_TEMP_OVER                0x53 /* not sure about this one */
+
+/*
+ * Conversions
+ * The W83L785TS-S uses signed 8-bit values.
+ */
+
+#define TEMP_FROM_REG(val)     (val & 0x80 ? val-0x100 : val)
+
+/*
+ * Functions declaration
+ */
+
+static int w83l785ts_attach_adapter(struct i2c_adapter *adapter);
+static int w83l785ts_detect(struct i2c_adapter *adapter, int address, unsigned
+       short flags, int kind);
+static int w83l785ts_detach_client(struct i2c_client *client);
+static u8 w83l785ts_read_value(struct i2c_client *client, u8 reg, u8 defval);
+static void w83l785ts_update_client(struct i2c_client *client);
+static void w83l785ts_temp(struct i2c_client *client, int operation, int
+       ctl_name, int *nrels_mag, long *results);
+
+/*
+ * Driver data (common to all clients)
+ */
+ 
+static struct i2c_driver w83l785ts_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "W83L785S-S sensor driver",
+       .id             = I2C_DRIVERID_W83L785TS,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = w83l785ts_attach_adapter,
+       .detach_client  = w83l785ts_detach_client,
+};
+
+/*
+ * Client data (each client gets its own)
+ */
+
+struct w83l785ts_data {
+       struct i2c_client client;
+       int sysctl_id;
+
+       struct semaphore update_lock;
+       char valid; /* zero until following fields are valid */
+       unsigned long last_updated; /* in jiffies */
+
+       /* registers values */
+       u8 temp, temp_over;
+};
+
+/*
+ * Proc entries
+ * These files are created for each detected W83L785TS-S.
+ */
+
+/* -- SENSORS SYSCTL START -- */
+
+#define W83L785TS_SYSCTL_TEMP  1200
+
+/* -- SENSORS SYSCTL END -- */
+
+
+static ctl_table w83l785ts_dir_table_template[] =
+{
+       {W83L785TS_SYSCTL_TEMP, "temp", NULL, 0, 0444, NULL,
+        &i2c_proc_real, &i2c_sysctl_real, NULL, &w83l785ts_temp},
+       {0}
+};
+
+/*
+ * Internal variables
+ */
+
+static int w83l785ts_id = 0;
+
+/*
+ * Real code
+ */
+
+static int w83l785ts_attach_adapter(struct i2c_adapter *adapter)
+{
+       return i2c_detect(adapter, &addr_data, w83l785ts_detect);
+}
+
+/*
+ * The following function does more than just detection. If detection
+ * succeeds, it also registers the new chip.
+ */
+static int w83l785ts_detect(struct i2c_adapter *adapter, int address,
+       unsigned short flags, int kind)
+{
+       struct i2c_client *new_client;
+       struct w83l785ts_data *data;
+       int err = 0;
+       const char *type_name = "";
+       const char *client_name = "";
+
+       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
+#ifdef DEBUG
+               printk(KERN_DEBUG "w83l785ts.o: I2C bus doesn't support "
+                       "byte read mode, skipping.\n");
+#endif
+               return 0;
+       }
+
+       if (!(data = kmalloc(sizeof(struct w83l785ts_data), GFP_KERNEL))) {
+               printk(KERN_ERR "w83l785ts.o: Out of memory in w83l785ts_detect "
+                       "(new_client).\n");
+               return -ENOMEM;
+       }
+
+       /*
+        * The common I2C client data is placed right after the
+        * W83L785TS-specific. The W83L785TS-specific data is pointed to by the
+        * data field from the I2C client data.
+        */
+
+       new_client = &data->client;
+       new_client->addr = address;
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &w83l785ts_driver;
+       new_client->flags = 0;
+
+       /*
+        * 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, W83L785TS-S). 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.
+        */
+
+       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)) {
+#ifdef DEBUG
+                       printk(KERN_DEBUG "w83l785ts.o: Detection failed at "
+                               "0x%02x.\n", address);
+#endif
+                       goto ERROR1;
+               }
+       }
+
+       if (kind <= 0) { /* identification */
+               u16 man_id;
+               u8 chip_id;
+
+               man_id = (w83l785ts_read_value(new_client, W83L785TS_REG_MAN_ID1, 0) << 8)
+                      +  w83l785ts_read_value(new_client, W83L785TS_REG_MAN_ID2, 0);
+               chip_id = w83l785ts_read_value(new_client, W83L785TS_REG_CHIP_ID, 0);
+               if (man_id == 0x5CA3) { /* Winbond */
+                       if (chip_id == 0x70)
+                               kind = w83l785ts;
+               }
+       }
+
+       if (kind <= 0) { /* identification failed */
+               printk(KERN_INFO "w83l785ts.o: Unsupported chip.\n");
+               goto ERROR1;
+       }
+
+       if (kind == w83l785ts) {
+               type_name = "w83l785ts";
+               client_name = "W83L785TS-S chip";
+       } else {
+               printk(KERN_ERR "w83l785ts.o: Unknown kind %d.\n", kind);
+               goto ERROR1;
+       }
+       
+       /*
+        * OK, we got a valid chip so we can fill in the remaining client
+        * fields.
+        */
+
+       strcpy(new_client->name, client_name);
+       new_client->id = w83l785ts_id++;
+       data->valid = 0;
+       init_MUTEX(&data->update_lock);
+
+       /*
+        * Tell the I2C layer a new client has arrived.
+        */
+
+       if ((err = i2c_attach_client(new_client))) {
+#ifdef DEBUG
+               printk(KERN_ERR "w83l785ts.o: Failed attaching client.\n");
+#endif
+               goto ERROR1;
+       }
+
+       /*
+        * Register a new directory entry.
+        */
+
+       if ((err = i2c_register_entry(new_client, type_name,
+           w83l785ts_dir_table_template)) < 0) {
+#ifdef DEBUG
+               printk(KERN_ERR "w83l785ts.o: Failed registering directory "
+                       "entry.\n");
+#endif
+               goto ERROR2;
+       }
+       data->sysctl_id = err;
+
+       /*
+        * Initialize the W83L785TS chip
+        * Nothing yet, assume it is already started.
+        */
+
+       return 0;
+
+       ERROR2:
+       i2c_detach_client(new_client);
+       ERROR1:
+       kfree(data);
+       return err;
+}
+
+static int w83l785ts_detach_client(struct i2c_client *client)
+{
+       int err;
+
+       i2c_deregister_entry(((struct w83l785ts_data *) (client->data))->sysctl_id);
+       if ((err = i2c_detach_client(client))) {
+               printk(KERN_ERR "w83l785ts.o: Client deregistration failed, "
+                       "client not detached.\n");
+               return err;
+       }
+
+       kfree(client->data);
+       return 0;
+}
+
+static u8 w83l785ts_read_value(struct i2c_client *client, u8 reg, u8 defval)
+{
+       int value, i;
+
+       /* Frequent read errors have been reported on Asus boards, so we
+        * retry on read errors. If it still fails (unlikely), return the
+        * default value requested by the caller. */
+       for (i = 1; i <= MAX_RETRIES; i++) {
+               value = i2c_smbus_read_byte_data(client, reg);
+               if (value >= 0)
+                       return value;
+               printk(KERN_WARNING "w83l785ts.o: Read failed, will retry "
+                       "in %d.\n", i);
+               mdelay(i);
+       }
+
+       printk(KERN_ERR "w83l785ts.o: Couldn't read value from register. "
+               "Please report.\n");
+       return defval;
+}
+
+static void w83l785ts_update_client(struct i2c_client *client)
+{
+       struct w83l785ts_data *data = client->data;
+
+       down(&data->update_lock);
+
+       if ((jiffies - data->last_updated > HZ * 2)
+        || (jiffies < data->last_updated)
+        || !data->valid) {
+#ifdef DEBUG
+               printk(KERN_DEBUG "w83l785ts.o: Updating data.\n");
+#endif
+               data->temp = w83l785ts_read_value(client, W83L785TS_REG_TEMP,
+                       data->temp);
+               data->temp_over = w83l785ts_read_value(client,
+                       W83L785TS_REG_TEMP_OVER, data->temp_over);
+               data->last_updated = jiffies;
+               data->valid = 1;
+       }
+
+       up(&data->update_lock);
+}
+
+static void w83l785ts_temp(struct i2c_client *client, int operation,
+       int ctl_name, int *nrels_mag, long *results)
+{
+       struct w83l785ts_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO) {
+               *nrels_mag = 0; /* magnitude */
+       } else if (operation == SENSORS_PROC_REAL_READ) {
+               w83l785ts_update_client(client);
+               results[0] = TEMP_FROM_REG(data->temp_over);
+               results[1] = TEMP_FROM_REG(data->temp);
+               *nrels_mag = 2;
+       }
+}
+
+static int __init sm_w83l785ts_init(void)
+{
+       printk(KERN_INFO "w83l785ts.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       return i2c_add_driver(&w83l785ts_driver);
+}
+
+static void __exit sm_w83l785ts_exit(void)
+{
+       i2c_del_driver(&w83l785ts_driver);
+}
+
+MODULE_AUTHOR("Jean Delvare <khali@linux-fr.org>");
+MODULE_DESCRIPTION("W83L785TS-S sensor driver");
+MODULE_LICENSE("GPL");
+
+module_init(sm_w83l785ts_init);
+module_exit(sm_w83l785ts_exit);
--- linux-old/drivers/sensors/xeontemp.c        Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/xeontemp.c    Mon Dec 13 20:18:54 2004
@@ -0,0 +1,388 @@
+/*
+    xeontemp.c - Part of lm_sensors, Linux kernel modules for hardware
+             monitoring
+    Copyright (c) 1998, 1999,2003  Frodo Looijaard <frodol@dds.nl>,
+    Philip Edelbrock <phil@netroedge.com>, and
+    Mark D. Studebaker <mdsxyz123@yahoo.com>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/* The Xeon temperature sensor looks just like an ADM1021 with the remote
+   sensor only. There is are no ID registers so detection is difficult. */
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/i2c-proc.h>
+#include <linux/init.h>
+#define LM_DATE "20041007"
+#define LM_VERSION "2.8.8"
+
+#ifndef I2C_DRIVERID_XEONTEMP
+#define I2C_DRIVERID_XEONTEMP  1045
+#endif
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = { 0x18, 0x1a, 0x29, 0x2b,
+       0x4c, 0x4e, SENSORS_I2C_END
+};
+static unsigned short normal_i2c_range[] = { SENSORS_I2C_END };
+static unsigned int normal_isa[] = { SENSORS_ISA_END };
+static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
+
+/* Insmod parameters */
+SENSORS_INSMOD_1(xeontemp);
+
+/* xeontemp constants specified below */
+
+/* The registers */
+/* Read-only */
+#define XEONTEMP_REG_REMOTE_TEMP 0x01
+#define XEONTEMP_REG_STATUS 0x02
+/* These use different addresses for reading/writing */
+#define XEONTEMP_REG_CONFIG_R 0x03
+#define XEONTEMP_REG_CONFIG_W 0x09
+#define XEONTEMP_REG_CONV_RATE_R 0x04
+#define XEONTEMP_REG_CONV_RATE_W 0x0A
+/* limits */
+#define XEONTEMP_REG_REMOTE_TOS_R 0x07
+#define XEONTEMP_REG_REMOTE_TOS_W 0x0D
+#define XEONTEMP_REG_REMOTE_THYST_R 0x08
+#define XEONTEMP_REG_REMOTE_THYST_W 0x0E
+/* write-only */
+#define XEONTEMP_REG_ONESHOT 0x0F
+
+#define XEONTEMP_ALARM_RTEMP (XEONTEMP_ALARM_RTEMP_HIGH | XEONTEMP_ALARM_RTEMP_LOW\
+                             | XEONTEMP_ALARM_RTEMP_NA)
+#define XEONTEMP_ALARM_ALL  XEONTEMP_ALARM_RTEMP
+
+/* Conversions. Rounding and limit checking is only done on the TO_REG
+   variants. Note that you should be a bit careful with which arguments
+   these macros are called: arguments may be evaluated more than once.
+   Fixing this is just not worth it. */
+/* Conversions  note: 1021 uses normal integer signed-byte format*/
+#define TEMP_FROM_REG(val) (val > 127 ? val-256 : val)
+#define TEMP_TO_REG(val)   (SENSORS_LIMIT((val < 0 ? val+256 : val),0,255))
+
+/* Each client has this additional data */
+struct xeontemp_data {
+       struct i2c_client client;
+       int sysctl_id;
+       enum chips type;
+
+       struct semaphore update_lock;
+       char valid;             /* !=0 if following fields are valid */
+       unsigned long last_updated;     /* In jiffies */
+
+       u8 remote_temp, remote_temp_os, remote_temp_hyst, alarms;
+       u8 fail;
+};
+
+static int xeontemp_attach_adapter(struct i2c_adapter *adapter);
+static int xeontemp_detect(struct i2c_adapter *adapter, int address,
+                         unsigned short flags, int kind);
+static void xeontemp_init_client(struct i2c_client *client);
+static int xeontemp_detach_client(struct i2c_client *client);
+static int xeontemp_read_value(struct i2c_client *client, u8 reg);
+static int xeontemp_rd_good(u8 *val, struct i2c_client *client, u8 reg, u8 mask);
+static int xeontemp_write_value(struct i2c_client *client, u8 reg,
+                              u16 value);
+static void xeontemp_remote_temp(struct i2c_client *client, int operation,
+                               int ctl_name, int *nrels_mag,
+                               long *results);
+static void xeontemp_alarms(struct i2c_client *client, int operation,
+                          int ctl_name, int *nrels_mag, long *results);
+static void xeontemp_update_client(struct i2c_client *client);
+
+/* (amalysh) read only mode, otherwise any limit's writing confuse BIOS */
+static int read_only = 0;
+
+
+/* This is the driver that will be inserted */
+static struct i2c_driver xeontemp_driver = {
+       .owner          = THIS_MODULE,
+       .name           = "Xeon temp sensor driver",
+       .id             = I2C_DRIVERID_XEONTEMP,
+       .flags          = I2C_DF_NOTIFY,
+       .attach_adapter = xeontemp_attach_adapter,
+       .detach_client  = xeontemp_detach_client,
+};
+
+/* -- SENSORS SYSCTL START -- */
+
+#define XEONTEMP_SYSCTL_REMOTE_TEMP 1201
+#define XEONTEMP_SYSCTL_ALARMS 1203
+
+#define XEONTEMP_ALARM_RTEMP_HIGH 0x10
+#define XEONTEMP_ALARM_RTEMP_LOW 0x08
+#define XEONTEMP_ALARM_RTEMP_NA 0x04
+
+/* -- SENSORS SYSCTL END -- */
+
+/* These files are created for each detected xeontemp. This is just a template;
+   though at first sight, you might think we could use a statically
+   allocated list, we need some way to get back to the parent - which
+   is done through one of the 'extra' fields which are initialized
+   when a new copy is allocated. */
+static ctl_table xeontemp_dir_table_template[] = {
+       {XEONTEMP_SYSCTL_REMOTE_TEMP, "temp", NULL, 0, 0644, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &xeontemp_remote_temp},
+       {XEONTEMP_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
+        &i2c_sysctl_real, NULL, &xeontemp_alarms},
+       {0}
+};
+
+static int xeontemp_id = 0;
+
+static int xeontemp_attach_adapter(struct i2c_adapter *adapter)
+{
+       return i2c_detect(adapter, &addr_data, xeontemp_detect);
+}
+
+static int xeontemp_detect(struct i2c_adapter *adapter, int address,
+                         unsigned short flags, int kind)
+{
+       int i;
+       struct i2c_client *new_client;
+       struct xeontemp_data *data;
+       int err = 0;
+       const char *type_name = "";
+       const char *client_name = "";
+
+       if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
+               goto error0;
+
+       /* OK. For now, we presume we have a valid client. We now create the
+          client structure, even though we cannot fill it completely yet.
+          But it allows us to access xeontemp_{read,write}_value. */
+
+       if (!(data = kmalloc(sizeof(struct xeontemp_data), GFP_KERNEL))) {
+               err = -ENOMEM;
+               goto error0;
+       }
+
+       new_client = &data->client;
+       new_client->addr = address;
+       new_client->data = data;
+       new_client->adapter = adapter;
+       new_client->driver = &xeontemp_driver;
+       new_client->flags = 0;
+
+       /* Now, we do the remaining detection. */
+
+       if (kind < 0) {
+               if (
+                   (xeontemp_read_value(new_client, XEONTEMP_REG_STATUS) &
+                    0x03) != 0x00)
+                       goto error1;
+       }
+
+       /* Determine the chip type. */
+
+       if (kind <= 0) {
+               kind = xeontemp;
+       }
+
+       type_name = "xeontemp";
+       client_name = "xeon sensors";
+
+       /* Fill in the remaining client fields and put it into the global list */
+       strcpy(new_client->name, client_name);
+       data->type = kind;
+
+       new_client->id = xeontemp_id++;
+       data->valid = 0;
+       init_MUTEX(&data->update_lock);
+
+       /* Tell the I2C layer a new client has arrived */
+       if ((err = i2c_attach_client(new_client)))
+               goto error3;
+
+       /* Register a new directory entry with module sensors */
+       if ((i = i2c_register_entry(new_client, type_name,
+                                   xeontemp_dir_table_template)) < 0) {
+               err = i;
+               goto error4;
+       }
+       data->sysctl_id = i;
+
+       xeontemp_init_client(new_client);
+       return 0;
+
+      error4:
+       i2c_detach_client(new_client);
+      error3:
+      error1:
+       kfree(data);
+      error0:
+       return err;
+}
+
+static void xeontemp_init_client(struct i2c_client *client)
+{
+       /* Enable ADC and disable suspend mode */
+       xeontemp_write_value(client, XEONTEMP_REG_CONFIG_W, 0);
+       /* Set Conversion rate to 1/sec (this can be tinkered with) */
+       xeontemp_write_value(client, XEONTEMP_REG_CONV_RATE_W, 0x04);
+}
+
+static int xeontemp_detach_client(struct i2c_client *client)
+{
+
+       int err;
+
+       i2c_deregister_entry(((struct xeontemp_data *) (client->data))->
+                                sysctl_id);
+
+       if ((err = i2c_detach_client(client))) {
+               printk
+                   ("xeontemp.o: Client deregistration failed, client not detached.\n");
+               return err;
+       }
+
+       kfree(client->data);
+
+       return 0;
+
+}
+
+
+/* All registers are byte-sized */
+static int xeontemp_read_value(struct i2c_client *client, u8 reg)
+{
+       return i2c_smbus_read_byte_data(client, reg);
+}
+
+/* only update value if read succeeded; set fail bit if failed */
+static int xeontemp_rd_good(u8 *val, struct i2c_client *client, u8 reg, u8 mask)
+{
+       int i;
+       struct xeontemp_data *data = client->data;
+
+       i = i2c_smbus_read_byte_data(client, reg);
+       if (i < 0) {
+               data->fail |= mask;
+               return i;
+       }
+       *val = i;
+       return 0;
+}
+
+static int xeontemp_write_value(struct i2c_client *client, u8 reg, u16 value)
+{
+       if (read_only > 0)
+               return 0;
+
+       return i2c_smbus_write_byte_data(client, reg, value);
+}
+
+static void xeontemp_update_client(struct i2c_client *client)
+{
+       struct xeontemp_data *data = client->data;
+
+       down(&data->update_lock);
+
+       if ((jiffies - data->last_updated > HZ + HZ / 2) ||
+           (jiffies < data->last_updated) || !data->valid) {
+
+#ifdef DEBUG
+               printk("Starting xeontemp update\n");
+#endif
+
+               data->fail = 0;
+               xeontemp_rd_good(&(data->remote_temp), client,
+                               XEONTEMP_REG_REMOTE_TEMP, XEONTEMP_ALARM_RTEMP);
+               xeontemp_rd_good(&(data->remote_temp_os), client,
+                               XEONTEMP_REG_REMOTE_TOS_R, XEONTEMP_ALARM_RTEMP);
+               xeontemp_rd_good(&(data->remote_temp_hyst), client,
+                               XEONTEMP_REG_REMOTE_THYST_R,
+                               XEONTEMP_ALARM_RTEMP);
+               data->alarms = XEONTEMP_ALARM_ALL;
+               if (!xeontemp_rd_good(&(data->alarms), client,
+                                    XEONTEMP_REG_STATUS, 0))
+                       data->alarms &= XEONTEMP_ALARM_ALL;
+               data->last_updated = jiffies;
+               data->valid = 1;
+       }
+
+       up(&data->update_lock);
+}
+
+void xeontemp_remote_temp(struct i2c_client *client, int operation,
+                        int ctl_name, int *nrels_mag, long *results)
+{
+       struct xeontemp_data *data = client->data;
+
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               xeontemp_update_client(client);
+               results[0] = TEMP_FROM_REG(data->remote_temp_os);
+               results[1] = TEMP_FROM_REG(data->remote_temp_hyst);
+               results[2] = TEMP_FROM_REG(data->remote_temp);
+               *nrels_mag = 3;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               if (*nrels_mag >= 1) {
+                       data->remote_temp_os = TEMP_TO_REG(results[0]);
+                       xeontemp_write_value(client,
+                                           XEONTEMP_REG_REMOTE_TOS_W,
+                                           data->remote_temp_os);
+               }
+               if (*nrels_mag >= 2) {
+                       data->remote_temp_hyst = TEMP_TO_REG(results[1]);
+                       xeontemp_write_value(client,
+                                           XEONTEMP_REG_REMOTE_THYST_W,
+                                           data->remote_temp_hyst);
+               }
+       }
+}
+
+void xeontemp_alarms(struct i2c_client *client, int operation, int ctl_name,
+                   int *nrels_mag, long *results)
+{
+       struct xeontemp_data *data = client->data;
+       if (operation == SENSORS_PROC_REAL_INFO)
+               *nrels_mag = 0;
+       else if (operation == SENSORS_PROC_REAL_READ) {
+               xeontemp_update_client(client);
+               results[0] = data->alarms | data->fail;
+               *nrels_mag = 1;
+       } else if (operation == SENSORS_PROC_REAL_WRITE) {
+               /* Can't write to it */
+       }
+}
+
+static int __init sm_xeontemp_init(void)
+{
+       printk(KERN_INFO "xeontemp.o version %s (%s)\n", LM_VERSION, LM_DATE);
+       return i2c_add_driver(&xeontemp_driver);
+}
+
+static void __exit sm_xeontemp_exit(void)
+{
+       i2c_del_driver(&xeontemp_driver);
+}
+
+MODULE_AUTHOR
+    ("Frodo Looijaard <frodol@dds.nl> and Philip Edelbrock <phil@netroedge.com>");
+MODULE_DESCRIPTION("xeontemp driver");
+MODULE_LICENSE("GPL");
+
+MODULE_PARM(read_only, "i");
+MODULE_PARM_DESC(read_only, "Don't set any values, read only mode");
+
+module_init(sm_xeontemp_init)
+module_exit(sm_xeontemp_exit)
--- linux-old/include/linux/sensors_compat.h    Thu Jan  1 00:00:00 1970
+++ linux/include/linux/sensors_compat.h        Mon Dec 13 20:18:54 2004
@@ -0,0 +1,31 @@
+/*
+ * Stolen from kernel 2.5.69
+ * device.h - generic, centralized driver model
+ * To make it easier to backport from 2.5
+ *
+ * Copyright (c) 2001-2003 Patrick Mochel <mochel@osdl.org>
+ *
+ */
+
+#ifndef _SENSORS_COMPAT_H_
+#define _SENSORS_COMPAT_H_
+
+/* debugging and troubleshooting/diagnostic helpers. */
+#define dev_printk(level, dev, format, arg...) \
+       printk(level "%s: " format , (dev)->name , ## arg)
+
+#ifdef DEBUG
+#define dev_dbg(dev, format, arg...)           \
+       dev_printk(KERN_DEBUG , dev , format , ## arg)
+#else
+#define dev_dbg(dev, format, arg...) do {} while (0)
+#endif
+
+#define dev_err(dev, format, arg...)           \
+       dev_printk(KERN_ERR , dev , format , ## arg)
+#define dev_info(dev, format, arg...)          \
+       dev_printk(KERN_INFO , dev , format , ## arg)
+#define dev_warn(dev, format, arg...)          \
+       dev_printk(KERN_WARNING , dev , format , ## arg)
+
+#endif /* _SENSORS_COMPAT_H_ */
--- linux-old/include/linux/sensors_vid.h       Thu Jan  1 00:00:00 1970
+++ linux/include/linux/sensors_vid.h   Mon Dec 13 20:18:54 2004
@@ -0,0 +1,95 @@
+/*
+    sensors_vid.h - Part of lm_sensors, Linux kernel modules for hardware
+               monitoring
+    Copyright (c) 2002-2004  Mark D. Studebaker <mdsxyz123@yahoo.com>
+    With assistance from Trent Piepho <xyzzy@speakeasy.org>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+    This file contains common code for decoding VID pins.
+    This file is #included in various sensor chip drivers.
+    As the user is unlikely to load more than one driver which
+    includes this code we don't worry about the wasted space.
+    References: VRM x.y DC-DC Converter Design Guidelines,
+                VRD 10.0 Design Guide,
+                available at http://developer.intel.com
+*/
+
+/*
+    AMD Opteron processors don't follow the Intel VRM spec.
+    I'm going to "make up" 2.4 as the VRM spec for the Opterons.
+    No good reason just a mnemonic for the 24x Opteron processor
+    series
+
+    Opteron VID encoding is:
+
+       00000  =  1.550 V
+       00001  =  1.525 V
+        . . . .
+       11110  =  0.800 V
+       11111  =  0.000 V (off)
+ */
+
+/*
+    Legal val values 00 - 1F except for VRD 10.0, 0x00-0x3f.
+    vrm is the Intel VRM document version.
+    Note: vrm version is scaled by 10 and the return value is scaled by 1000
+    to avoid floating point in the kernel.
+*/
+
+#define DEFAULT_VRM    82
+
+static inline int vid_from_reg(int val, int vrm)
+{
+       int vid;
+
+       switch(vrm) {
+
+       case 100:               /* VRD 10.0 */
+               if((val & 0x1f) == 0x1f)
+                       return 0;
+               if((val & 0x1f) <= 0x09 || val == 0x0a)
+                       vid = 10875 - (val & 0x1f) * 250;
+               else
+                       vid = 18625 - (val & 0x1f) * 250;
+               if(val & 0x20)
+                       vid -= 125;
+               vid /= 10;      /* only return 3 dec. places for now */
+               return vid;
+
+       case 24:                /* Opteron processor */
+               return(val == 0x1f ? 0 : 1550 - val * 25);
+
+       case 91:                /* VRM 9.1 */
+       case 90:                /* VRM 9.0 */
+               return(val == 0x1f ? 0 :
+                                      1850 - val * 25);
+
+       case 85:                /* VRM 8.5 */
+               return((val & 0x10  ? 25 : 0) +
+                      ((val & 0x0f) > 0x04 ? 2050 : 1250) -
+                      ((val & 0x0f) * 50));
+
+       case 84:                /* VRM 8.4 */
+               val &= 0x0f;
+                               /* fall through */
+       default:                /* VRM 8.2 */
+               return(val == 0x1f ? 0 :
+                      val & 0x10  ? 5100 - (val) * 100 :
+                                    2050 - (val) * 50);
+       }
+}
--- linux-old/drivers/sensors/Config.in Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/Config.in     Mon Dec 13 20:18:54 2004
@@ -0,0 +1,62 @@
+#
+# Sensor device configuration
+# All depend on CONFIG_I2C_PROC.
+# ISA-only devices depend on CONFIG_I2C_ISA also.
+#
+
+if [ "$CONFIG_I2C" = "m" -o "$CONFIG_I2C" = "y" ] ; then
+if [ "$CONFIG_I2C_PROC" = "m" -o "$CONFIG_I2C_PROC" = "y" ] ; then
+  mainmenu_option next_comment
+  comment 'Hardware sensors support'
+  
+  dep_mbool 'Hardware sensors support' CONFIG_SENSORS $CONFIG_I2C $CONFIG_I2C_PROC
+  
+  if [ "$CONFIG_SENSORS" != "n" ]; then
+    dep_tristate '  Analog Devices ADM1021 and compatibles' CONFIG_SENSORS_ADM1021 $CONFIG_I2C $CONFIG_I2C_PROC
+    dep_tristate '  Analog Devices ADM1024' CONFIG_SENSORS_ADM1024 $CONFIG_I2C $CONFIG_I2C_PROC
+    dep_tristate '  Analog Devices ADM1025' CONFIG_SENSORS_ADM1025 $CONFIG_I2C $CONFIG_I2C_PROC
+    dep_tristate '  Analog Devices ADM1026' CONFIG_SENSORS_ADM1026 $CONFIG_I2C $CONFIG_I2C_PROC
+    dep_tristate '  Analog Devices ADM9240 and compatibles' CONFIG_SENSORS_ADM9240 $CONFIG_I2C $CONFIG_I2C_PROC
+    dep_tristate '  Asus ASB100' CONFIG_SENSORS_ASB100 $CONFIG_I2C $CONFIG_I2C_PROC
+    dep_tristate '  Dallas DS1621 and DS1625' CONFIG_SENSORS_DS1621 $CONFIG_I2C $CONFIG_I2C_PROC
+    dep_tristate '  Fujitsu-Siemens Poseidon' CONFIG_SENSORS_FSCPOS $CONFIG_I2C $CONFIG_I2C_PROC
+    dep_tristate '  Fujitsu-Siemens Scylla' CONFIG_SENSORS_FSCSCY $CONFIG_I2C $CONFIG_I2C_PROC
+    dep_tristate '  Genesys Logic GL518SM' CONFIG_SENSORS_GL518SM $CONFIG_I2C $CONFIG_I2C_PROC
+    dep_tristate '  Genesys Logic GL520SM' CONFIG_SENSORS_GL520SM $CONFIG_I2C $CONFIG_I2C_PROC
+    dep_tristate '  HP Maxilife' CONFIG_SENSORS_MAXILIFE $CONFIG_I2C $CONFIG_I2C_PROC
+    dep_tristate '  Intel Xeon Thermal Sensor' CONFIG_SENSORS_XEONTEMP $CONFIG_I2C $CONFIG_I2C_PROC
+    dep_tristate '  ITE 8705/8712, SiS950' CONFIG_SENSORS_IT87 $CONFIG_I2C $CONFIG_I2C_PROC
+    dep_tristate '  Maxim MAX6650, MAX6651' CONFIG_SENSORS_MAX6650 $CONFIG_I2C $CONFIG_I2C_PROC
+    dep_tristate '  Myson MTP008' CONFIG_SENSORS_MTP008 $CONFIG_I2C $CONFIG_I2C_PROC
+    dep_tristate '  National Semiconductor LM75 and compatibles' CONFIG_SENSORS_LM75 $CONFIG_I2C $CONFIG_I2C_PROC
+    dep_tristate '  National Semiconductor LM78' CONFIG_SENSORS_LM78 $CONFIG_I2C $CONFIG_I2C_PROC
+    dep_tristate '  National Semiconductor LM80' CONFIG_SENSORS_LM80 $CONFIG_I2C $CONFIG_I2C_PROC
+    dep_tristate '  National Semiconductor LM83' CONFIG_SENSORS_LM83 $CONFIG_I2C $CONFIG_I2C_PROC
+    dep_tristate '  National Semiconductor LM85, Analog Devices ADM1027' CONFIG_SENSORS_LM85 $CONFIG_I2C $CONFIG_I2C_PROC
+    dep_tristate '  National Semiconductor LM87' CONFIG_SENSORS_LM87 $CONFIG_I2C $CONFIG_I2C_PROC
+    dep_tristate '  National Semiconductor LM90 and compatibles' CONFIG_SENSORS_LM90 $CONFIG_I2C $CONFIG_I2C_PROC
+    dep_tristate '  National Semiconductor LM92' CONFIG_SENSORS_LM92 $CONFIG_I2C $CONFIG_I2C_PROC
+    dep_tristate '  National Semiconductor PC8736x Sensors' CONFIG_SENSORS_PC87360 $CONFIG_I2C $CONFIG_I2C_PROC
+    dep_tristate '  Silicon Integrated Systems Corp. SiS5595' CONFIG_SENSORS_SIS5595 $CONFIG_I2C $CONFIG_I2C_PROC $CONFIG_I2C_ISA
+    dep_tristate '  SMSC47M1xx Integrated Sensors' CONFIG_SENSORS_SMSC47M1 $CONFIG_I2C $CONFIG_I2C_PROC $CONFIG_I2C_ISA
+    dep_tristate '  Texas Instruments THMC50 and compatibles' CONFIG_SENSORS_THMC50 $CONFIG_I2C $CONFIG_I2C_PROC
+    dep_tristate '  VIA 686a Integrated Hardware Monitor' CONFIG_SENSORS_VIA686A $CONFIG_I2C $CONFIG_I2C_PROC $CONFIG_I2C_ISA
+    dep_tristate '  VIA VT1211 Integrated Sensors' CONFIG_SENSORS_VT1211 $CONFIG_I2C $CONFIG_I2C_PROC $CONFIG_I2C_ISA
+    dep_tristate '  VIA VT8231 Integrated Sensors' CONFIG_SENSORS_VT8231 $CONFIG_I2C $CONFIG_I2C_PROC $CONFIG_I2C_ISA
+    dep_tristate '  Winbond W83781D, W83782D, W83783S, W83627HF, Asus AS99127F' CONFIG_SENSORS_W83781D $CONFIG_I2C $CONFIG_I2C_PROC
+    dep_tristate '  Winbond W83627HF, W83627THF, W83697HF' CONFIG_SENSORS_W83627HF $CONFIG_I2C $CONFIG_I2C_PROC $CONFIG_I2C_ISA
+    dep_tristate '  Winbond W83L785TS-S' CONFIG_SENSORS_W83L785TS $CONFIG_I2C $CONFIG_I2C_PROC
+    bool 'Other I2C devices' CONFIG_SENSORS_OTHER 
+    if [ "$CONFIG_SENSORS_OTHER" = "y" ] ; then
+      dep_tristate '  Brooktree BT869 Video Modulator' CONFIG_SENSORS_BT869 $CONFIG_I2C $CONFIG_I2C_PROC
+      dep_tristate '  DDC Monitor EDID EEPROM' CONFIG_SENSORS_DDCMON $CONFIG_I2C $CONFIG_I2C_PROC
+      dep_tristate '  EEprom (DIMM) reader ' CONFIG_SENSORS_EEPROM $CONFIG_I2C $CONFIG_I2C_PROC
+      dep_tristate '  Matrix-Orbital LCD Displays' CONFIG_SENSORS_MATORB $CONFIG_I2C $CONFIG_I2C_PROC
+      dep_tristate '  Philips PCF8574 Parallel I/O' CONFIG_SENSORS_PCF8574 $CONFIG_I2C $CONFIG_I2C_PROC
+      dep_tristate '  Philips PCF8591 D/A and A/D' CONFIG_SENSORS_PCF8591 $CONFIG_I2C $CONFIG_I2C_PROC
+    fi
+  fi
+  endmenu
+fi
+fi
+
--- linux-old/Makefile  Sat Aug 14 18:38:44 2004
+++ linux/Makefile      Mon Dec 13 20:18:54 2004
@@ -195,6 +195,7 @@
 DRIVERS-$(CONFIG_ISDN_BOOL) += drivers/isdn/vmlinux-obj.o
 DRIVERS-$(CONFIG_CRYPTO) += crypto/crypto.o
 
+DRIVERS-$(CONFIG_SENSORS) += drivers/sensors/sensor.o
 DRIVERS := $(DRIVERS-y)
 
 
--- linux-old/drivers/Makefile  Mon Nov 17 01:07:35 2003
+++ linux/drivers/Makefile      Mon Dec 13 20:18:54 2004
@@ -8,7 +8,7 @@
 
 mod-subdirs := dio hil mtd sbus video macintosh usb input telephony ide \
                message/i2o message/fusion scsi md ieee1394 pnp isdn atm \
-               fc4 net/hamradio i2c acpi bluetooth usb/gadget
+               fc4 net/hamradio i2c acpi bluetooth usb/gadget sensors
 
 subdir-y :=    parport char block net sound misc media cdrom hotplug
 subdir-m :=    $(subdir-y)
@@ -45,6 +45,7 @@
 # CONFIG_HAMRADIO can be set without CONFIG_NETDEVICE being set  -- ch
 subdir-$(CONFIG_HAMRADIO)      += net/hamradio
 subdir-$(CONFIG_I2C)           += i2c
+subdir-$(CONFIG_SENSORS)       += sensors
 subdir-$(CONFIG_ACPI_BOOT)     += acpi
 
 subdir-$(CONFIG_BLUEZ)         += bluetooth
--- linux-old/drivers/sensors/Makefile  Thu Jan  1 00:00:00 1970
+++ linux/drivers/sensors/Makefile      Mon Dec 13 20:18:54 2004
@@ -0,0 +1,49 @@
+#
+# Makefile for the kernel hardware sensors drivers.
+#
+
+MOD_LIST_NAME := SENSORS_MODULES
+O_TARGET := sensor.o
+
+obj-$(CONFIG_SENSORS_ADM1021)  += adm1021.o
+obj-$(CONFIG_SENSORS_ADM1024)  += adm1024.o
+obj-$(CONFIG_SENSORS_ADM1025)  += adm1025.o
+obj-$(CONFIG_SENSORS_ADM1026)  += adm1026.o
+obj-$(CONFIG_SENSORS_ADM9240)  += adm9240.o
+obj-$(CONFIG_SENSORS_ASB100)   += asb100.o
+obj-$(CONFIG_SENSORS_BT869)    += bt869.o
+obj-$(CONFIG_SENSORS_DDCMON)   += ddcmon.o
+obj-$(CONFIG_SENSORS_DS1621)   += ds1621.o
+obj-$(CONFIG_SENSORS_EEPROM)   += eeprom.o
+obj-$(CONFIG_SENSORS_FSCPOS)   += fscpos.o
+obj-$(CONFIG_SENSORS_FSCSCY)   += fscscy.o
+obj-$(CONFIG_SENSORS_GL518SM)  += gl518sm.o
+obj-$(CONFIG_SENSORS_GL520SM)  += gl520sm.o
+obj-$(CONFIG_SENSORS_IT87)     += it87.o
+obj-$(CONFIG_SENSORS_LM75)     += lm75.o
+obj-$(CONFIG_SENSORS_LM78)     += lm78.o
+obj-$(CONFIG_SENSORS_LM80)     += lm80.o
+obj-$(CONFIG_SENSORS_LM83)     += lm83.o
+obj-$(CONFIG_SENSORS_LM85)     += lm85.o
+obj-$(CONFIG_SENSORS_LM87)     += lm87.o
+obj-$(CONFIG_SENSORS_LM90)     += lm90.o
+obj-$(CONFIG_SENSORS_LM92)     += lm92.o
+obj-$(CONFIG_SENSORS_MAX6650)  += max6650.o
+obj-$(CONFIG_SENSORS_MAXILIFE) += maxilife.o
+obj-$(CONFIG_SENSORS_MTP008)   += mtp008.o
+obj-$(CONFIG_SENSORS_PC87360)  += pc87360.o
+obj-$(CONFIG_SENSORS_PCF8574)  += pcf8574.o
+obj-$(CONFIG_SENSORS_PCF8591)  += pcf8591.o
+obj-$(CONFIG_SENSORS_SIS5595)  += sis5595.o
+obj-$(CONFIG_SENSORS_SMSC47M1) += smsc47m1.o
+obj-$(CONFIG_SENSORS_THMC50)   += thmc50.o
+obj-$(CONFIG_SENSORS_VIA686A)  += via686a.o
+obj-$(CONFIG_SENSORS_VT1211)   += vt1211.o
+obj-$(CONFIG_SENSORS_VT8231)   += vt8231.o
+obj-$(CONFIG_SENSORS_W83781D)  += w83781d.o
+obj-$(CONFIG_SENSORS_W83627HF) += w83627hf.o
+obj-$(CONFIG_SENSORS_W83L785TS)        += w83l785ts.o
+obj-$(CONFIG_SENSORS_XEONTEMP) += xeontemp.o
+
+include $(TOPDIR)/Rules.make
+
--- linux-old/drivers/char/Config.in    Sat Aug 14 18:38:49 2004
+++ linux/drivers/char/Config.in        Mon Dec 13 20:18:54 2004
@@ -191,6 +191,8 @@
 
 source drivers/i2c/Config.in
 
+source drivers/sensors/Config.in
+
 mainmenu_option next_comment
 comment 'Mice'
 tristate 'Bus Mouse Support' CONFIG_BUSMOUSE
--- linux-old/drivers/i2c/Config.in     Wed Jul  7 00:38:02 2004
+++ linux/drivers/i2c/Config.in Mon Dec 13 20:18:54 2004
@@ -63,6 +63,30 @@
    fi
  
 # This is needed for automatic patch generation: sensors code starts here
+  bool 'I2C mainboard interfaces' CONFIG_I2C_MAINBOARD 
+  if [ "$CONFIG_I2C_MAINBOARD" = "y" ]; then
+    dep_tristate '  Acer Labs ALI 1535' CONFIG_I2C_ALI1535 $CONFIG_I2C
+    dep_tristate '  Acer Labs ALI 1533 and 1543C' CONFIG_I2C_ALI15X3 $CONFIG_I2C
+    dep_tristate '  Apple Hydra Mac I/O' CONFIG_I2C_HYDRA $CONFIG_I2C_ALGOBIT
+    dep_tristate '  AMD 756/766/768/8111' CONFIG_I2C_AMD756 $CONFIG_I2C
+    dep_tristate '  AMD 8111 SMBus 2.0' CONFIG_I2C_AMD8111 $CONFIG_I2C
+    if [ "$CONFIG_ALPHA" = "y" ]; then
+      dep_tristate '  DEC Tsunami I2C interface' CONFIG_I2C_TSUNAMI $CONFIG_I2C_ALGOBIT
+    fi
+    dep_tristate '  Intel 82801AA, AB, BA, DB' CONFIG_I2C_I801 $CONFIG_I2C
+    dep_tristate '  Intel i810AA/AB/E and i815' CONFIG_I2C_I810 $CONFIG_I2C_ALGOBIT
+    dep_tristate '  Intel 82371AB PIIX4(E), 443MX, ServerWorks OSB4/CSB5, SMSC Victory66' CONFIG_I2C_PIIX4 $CONFIG_I2C
+    dep_tristate '  Nvidia Nforce2' CONFIG_I2C_NFORCE2 $CONFIG_I2C
+    dep_tristate '  SiS 5595' CONFIG_I2C_SIS5595 $CONFIG_I2C
+    dep_tristate '  SiS 630/730' CONFIG_I2C_SIS630 $CONFIG_I2C
+    dep_tristate '  SiS 645/961,645DX/961,735' CONFIG_I2C_SIS645 $CONFIG_I2C $CONFIG_HOTPLUG
+    dep_tristate '  Savage 4' CONFIG_I2C_SAVAGE4 $CONFIG_I2C_ALGOBIT
+    dep_tristate '  VIA Technologies, Inc. VT82C586B' CONFIG_I2C_VIA $CONFIG_I2C_ALGOBIT
+    dep_tristate '  VIA Technologies, Inc. VT596A/B, 686A/B, 8231, 8233, 8233A, 8235' CONFIG_I2C_VIAPRO $CONFIG_I2C
+    dep_tristate '  Voodoo3 I2C interface' CONFIG_I2C_VOODOO3 $CONFIG_I2C_ALGOBIT
+    dep_tristate '  Pseudo ISA adapter (for some hardware sensors)' CONFIG_I2C_ISA $CONFIG_I2C
+  fi
+
 # This is needed for automatic patch generation: sensors code ends here
 
    dep_tristate 'I2C device interface' CONFIG_I2C_CHARDEV $CONFIG_I2C
--- linux-old/drivers/i2c/Makefile      Wed Jul  7 00:38:02 2004
+++ linux/drivers/i2c/Makefile  Mon Dec 13 20:18:54 2004
@@ -28,6 +28,24 @@
 obj-$(CONFIG_I2C_ALGO_AU1550)  += i2c-algo-au1550.o i2c-au1550.o
 
 # This is needed for automatic patch generation: sensors code starts here
+obj-$(CONFIG_I2C_ALI1535)              += i2c-ali1535.o
+obj-$(CONFIG_I2C_ALI15X3)              += i2c-ali15x3.o
+obj-$(CONFIG_I2C_AMD756)               += i2c-amd756.o
+obj-$(CONFIG_I2C_AMD8111)              += i2c-amd8111.o
+obj-$(CONFIG_I2C_HYDRA)                        += i2c-hydra.o
+obj-$(CONFIG_I2C_I801)                 += i2c-i801.o
+obj-$(CONFIG_I2C_I810)                 += i2c-i810.o
+obj-$(CONFIG_I2C_ISA)                  += i2c-isa.o
+obj-$(CONFIG_I2C_NFORCE2)              += i2c-nforce2.o
+obj-$(CONFIG_I2C_PIIX4)                        += i2c-piix4.o
+obj-$(CONFIG_I2C_SIS5595)              += i2c-sis5595.o
+obj-$(CONFIG_I2C_SIS630)               += i2c-sis630.o
+obj-$(CONFIG_I2C_SIS645)               += i2c-sis645.o
+obj-$(CONFIG_I2C_SAVAGE4)              += i2c-savage4.o
+obj-$(CONFIG_I2C_TSUNAMI)              += i2c-tsunami.o
+obj-$(CONFIG_I2C_VIA)                  += i2c-via.o
+obj-$(CONFIG_I2C_VIAPRO)               += i2c-viapro.o
+obj-$(CONFIG_I2C_VOODOO3)              += i2c-voodoo3.o
 # This is needed for automatic patch generation: sensors code ends here
 
 include $(TOPDIR)/Rules.make
--- linux-old/Documentation/Configure.help      Mon Dec 13 20:09:52 2004
+++ linux/Documentation/Configure.help  Mon Dec 13 20:18:56 2004
@@ -29449,4 +29449,527 @@
 # fill-prefix:"  "
 # adaptive-fill:nil
 # fill-column:70
+I2C mainboard interfaces
+CONFIG_I2C_MAINBOARD
+  Many modern mainboards have some kind of I2C interface integrated. This
+  is often in the form of a SMBus, or System Management Bus, which is
+  basically the same as I2C but which uses only a subset of the I2C
+  protocol.
+
+  You will also want the latest user-space utilties: you can find them
+  in the lm_sensors package, which you can download at 
+  http://www.lm-sensors.nu
+
+Acer Labs ALI 1535
+CONFIG_I2C_ALI1535
+  If you say yes to this option, support will be included for the Acer
+  Labs ALI 1535 mainboard I2C interface. This can also be 
+  built as a module.
+
+Acer Labs ALI 1533 and 1543C
+CONFIG_I2C_ALI15X3
+  If you say yes to this option, support will be included for the Acer
+  Labs ALI 1533 and 1543C mainboard I2C interfaces. This can also be 
+  built as a module which can be inserted and removed while the kernel
+  is running.
+
+AMD 756/766/768/8111
+CONFIG_I2C_AMD756
+  If you say yes to this option, support will be included for the AMD
+  756/766/768/8111 mainboard I2C interfaces. This can also be 
+  built as a module which can be inserted and removed while the kernel
+  is running.
+
+AMD 8111 SMBus 2.0
+CONFIG_I2C_AMD8111
+  If you say yes to this option, support will be included for the AMD
+  8111 mainboard SMBus 2.0 interface. This can also be 
+  built as a module which can be inserted and removed while the kernel
+  is running.
+
+Apple Hydra Mac I/O
+CONFIG_I2C_HYDRA
+  If you say yes to this option, support will be included for the 
+  Hydra mainboard I2C interface. This can also be built as a module 
+  which can be inserted and removed while the kernel is running.
+
+Intel I801
+CONFIG_I2C_I801
+  If you say yes to this option, support will be included for the 
+  Intel I801 mainboard I2C interfaces. "I810" mainboard sensor chips are
+  generally located on the I801's I2C bus. This can also be
+  built as a module which can be inserted and removed while the kernel
+  is running.
+
+Intel I810/I815 based Mainboard
+CONFIG_I2C_I810
+  If you say yes to this option, support will be included for the 
+  Intel I810/I815 mainboard I2C interfaces. The I2C busses these chips
+  are generally used only for video devices. For "810" mainboard sensor
+  chips, use the I801 I2C driver instead. This can also be
+  built as a module which can be inserted and removed while the kernel
+  is running.
+
+Intel 82371AB PIIX4(E) / ServerWorks OSB4 and CSB5
+CONFIG_I2C_PIIX4
+  If you say yes to this option, support will be included for the 
+  Intel PIIX4, PIIX4E, and 443MX, Serverworks OSB4/CSB5,
+  and SMSC Victory66 mainboard
+  I2C interfaces. This can also be
+  built as a module which can be inserted and removed while the kernel
+  is running.
+
+Nvidia Nforce2 based Mainboard
+CONFIG_I2C_NFORCE2
+  If you say yes to this option, support will be included for the 
+  Nvidia Nforce2 family of mainboard I2C interfaces. This can also be
+  built as a module which can be inserted and removed while the kernel
+  is running.
+
+Silicon Integrated Systems Corp. SiS5595 based Mainboard
+CONFIG_I2C_SIS5595
+  If you say yes to this option, support will be included for the 
+  SiS5595 mainboard I2C interfaces. For integrated sensors on the
+  Sis5595, use CONFIG_SENSORS_SIS5595. This can also be
+  built as a module which can be inserted and removed while the kernel
+  is running.
+
+Silicon Integrated Systems Corp. SiS630/730 based Mainboard
+CONFIG_I2C_SIS630
+  If you say yes to this option, support will be included for the SiS 630
+  and 730 mainboard I2C interfaces. This can also be built as a module 
+  which can be inserted and removed while the kernel is running.
+
+Silicon Integrated Systems Corp. SiS645/961,645DX/961,735 based Mainboard
+CONFIG_I2C_SIS645
+  If you say yes to this option, support will be included for the SiS 645/961,
+  645DX/961 and 735 mainboard I2C interfaces. This can also be built as a module
+  which can be inserted and removed while the kernel is running.
+
+VIA Technologies, Inc. VT82C586B
+CONFIG_I2C_VIA
+  If you say yes to this option, support will be included for the VIA
+  Technologies I2C adapter found on some motherboards. This can also 
+  be built as a module which can be inserted and removed while the 
+  kernel is running.
+
+VIA Technologies, Inc. VT82C596, 596B, 686A/B, 8233, 8235
+CONFIG_I2C_VIAPRO
+  If you say yes to this option, support will be included for the VIA
+  Technologies I2C adapter on these chips. For integrated sensors on the
+  Via 686A/B, use CONFIG_SENSORS_VIA686A. This can also be
+  be built as a module which can be inserted and removed while the 
+  kernel is running.
+
+3DFX Banshee / Voodoo3
+CONFIG_I2C_VOODOO3
+  If you say yes to this option, support will be included for the 
+  3DFX Banshee and Voodoo3 I2C interfaces. The I2C busses on the these
+  chips are generally used only for video devices.
+  This can also be
+  built as a module which can be inserted and removed while the kernel
+  is running.
+
+DEC Tsunami 21272
+CONFIG_I2C_TSUNAMI
+  If you say yes to this option, support will be included for the DEC
+  Tsunami chipset I2C adapter. Requires the Alpha architecture;
+  do not enable otherwise. This can also be built as a module which
+  can be inserted and removed while the kernel is running.
+
+Pseudo ISA adapter (for hardware sensors modules)
+CONFIG_I2C_ISA
+  This provides support for accessing some hardware sensor chips over
+  the ISA bus rather than the I2C or SMBus. If you want to do this, 
+  say yes here. This feature can also be built as a module which can 
+  be inserted and removed while the kernel is running.
+
+  You will also need the latest user-space utilties: you can find them
+  in the lm_sensors package, which you can download at 
+  http://www.lm-sensors.nu
+
+Analog Devices ADM1021 and compatibles
+CONFIG_SENSORS_ADM1021
+  If you say yes here you get support for Analog Devices ADM1021 
+  and ADM1023 sensor chips and clones: Maxim MAX1617 and MAX1617A,
+  Genesys Logic GL523SM, National Semi LM84, TI THMC10 and Onsemi
+  MC1066. This can also be built as a module which can be inserted
+  and removed while the kernel is running.
+
+  You will also need the latest user-space utilties: you can find them
+  in the lm_sensors package, which you can download at 
+  http://www.lm-sensors.nu
+
+Analog Devices ADM1024
+CONFIG_SENSORS_ADM1024
+  If you say yes here you get support for Analog Devices ADM1024 sensor
+  chips.  This can also be built as a module.
+
+  You will also need the latest user-space utilties: you can find them
+  in the lm_sensors package, which you can download at 
+  http://www.lm-sensors.nu
+
+Analog Devices ADM1025
+CONFIG_SENSORS_ADM1025
+  If you say yes here you get support for Analog Devices ADM1025 sensor
+  chips.  This can also be built as a module which can be inserted and
+  removed while the kernel is running.
+
+  You will also need the latest user-space utilties: you can find them
+  in the lm_sensors package, which you can download at 
+  http://www.lm-sensors.nu
+
+Analog Devices ADM1026
+CONFIG_SENSORS_ADM1026
+  If you say yes here you get support for Analog Devices ADM1026 sensor
+  chips.  This can also be built as a module which can be inserted and
+  removed while the kernel is running.
+
+  You will also need the latest user-space utilties: you can find them
+  in the lm_sensors package, which you can download at 
+  http://www.lm-sensors.nu
+
+Analog Devices ADM9240 and compatibles
+CONFIG_SENSORS_ADM9240
+  If you say yes here you get support for Analog Devices ADM9240 
+  sensor chips and clones: the Dallas Semiconductor DS1780 and
+  the National Semiconductor LM81. This can also be built as a 
+  module which can be inserted and removed while the kernel is
+  running.
+
+  You will also need the latest user-space utilties: you can find them
+  in the lm_sensors package, which you can download at 
+  http://www.lm-sensors.nu
+
+Asus ASB100
+CONFIG_SENSORS_ASB100
+  If you say yes here you get support for the Asus ASB100 (aka
+  "Bach") sensor chip.  This can also be built as a module.
+
+  You will also need the latest user-space utilities: you can find
+  them in the lm_sensors package, which you can download at
+  http://www.lm-sensors.nu/
+
+Dallas DS1621 and DS1625
+CONFIG_SENSORS_DS1621
+  If you say yes here you get support for the Dallas DS1621 and DS1625x
+  sensor chips.  This can also be built as a module.
+
+  You will also need the latest user-space utilties: you can find them
+  in the lm_sensors package, which you can download at 
+  http://www.lm-sensors.nu
+
+Fujitsu-Siemens Poseidon
+CONFIG_SENSORS_FSCPOS
+  If you say yes here you get support for the Fujitsu-Siemens Poseidon
+  sensor chip.  This can also be built as a module.
+
+  You will also need the latest user-space utilties: you can find them
+  in the lm_sensors package, which you can download at 
+  http://www.lm-sensors.nu
+
+Fujitsu-Siemens Scylla
+CONFIG_SENSORS_FSCSCY
+  If you say yes here you get support for the Fujitsu-Siemens Scylla
+  sensor chip.  This can also be built as a module. This driver may/should
+  also work with the following Fujitsu-Siemens chips: "Poseidon",
+  "Poseidon II" and "Hydra". You may have to force loading of the module
+  for motherboards in these cases. Be careful - those motherboards have
+  not been tested with this driver.
+
+  You will also need the latest user-space utilties: you can find them
+  in the lm_sensors package, which you can download at 
+  http://www.lm-sensors.nu
+
+Genesys Logic GL518SM
+CONFIG_SENSORS_GL518SM
+  If you say yes here you get support for Genesys Logic GL518SM sensor
+  chips.  This can also be built as a module which can be inserted and
+  removed while the kernel is running.
+
+  You will also need the latest user-space utilties: you can find them
+  in the lm_sensors package, which you can download at 
+  http://www.lm-sensors.nu
+
+Genesys Logic GL520SM
+CONFIG_SENSORS_GL520SM
+  If you say yes here you get support for Genesys Logic GL518SM sensor
+  chips.  This can also be built as a module which can be inserted and
+  removed while the kernel is running.
+
+  You will also need the latest user-space utilties: you can find them
+  in the lm_sensors package, which you can download at 
+  http://www.lm-sensors.nu
+
+HP Maxilife
+CONFIG_SENSORS_MAXILIFE
+  If you say yes here you get support for the HP Maxilife
+  sensor chip.  This can also be built as a module.
+
+  You will also need the latest user-space utilties: you can find them
+  in the lm_sensors package, which you can download at 
+  http://www.lm-sensors.nu
+
+Intel Xeon Thermal Sensor
+CONFIG_SENSORS_XEONTEMP
+  If you say yes here you get support for the Intel Xeon processor
+  built-in thermal sensor. This can also be built as a module which
+  can be inserted and removed while the kernel is running.
+
+  You will also need the latest user-space utilities: you can find them
+  in the lm_sensors package, which you can download at 
+  http://www.lm-sensors.nu/
+
+ITE 8705, 8712, Sis950
+CONFIG_SENSORS_IT87
+  If you say yes here you get support for the ITE 8705 and 8712 and
+  SiS950 sensor chips.  This can also be built as a module.
+
+  You will also need the latest user-space utilties: you can find them
+  in the lm_sensors package, which you can download at 
+  http://www.lm-sensors.nu
+
+Maxim MAX6650, MAX6651
+CONFIG_SENSORS_MAX6650
+  If you say yes here you get support for the Maxim MAX6650 and
+  MAX6651 sensor chips.  This can also be built as a module.
+
+  You will also need the latest user-space utilties: you can find them
+  in the lm_sensors package, which you can download at 
+  http://www.lm-sensors.nu
+
+Myson MTP008
+CONFIG_SENSORS_MTP008
+  If you say yes here you get support for the Myson MTP008
+  sensor chip.  This can also be built as a module.
+
+  You will also need the latest user-space utilties: you can find them
+  in the lm_sensors package, which you can download at 
+  http://www.lm-sensors.nu
+
+National Semiconductor LM75 and compatibles
+CONFIG_SENSORS_LM75 
+  If you say yes here you get support for National Semiconductor LM75
+  sensor chips and clones: Dallas Semiconductor DS75 and DS1775 (in
+  9-bit precision mode), and TelCom (now Microchip) TCN75. This can
+  also be built as a module which can be inserted and removed while
+  the kernel is running.
+
+  You will also need the latest user-space utilties: you can find them
+  in the lm_sensors package, which you can download at 
+  http://www.lm-sensors.nu
+
+National Semiconductor LM78
+CONFIG_SENSORS_LM78
+  If you say yes here you get support for National Semiconductor LM78
+  sensor chips family: the LM78-J and LM79. Many clone chips will
+  also work at least somewhat with this driver. This can also be built
+  as a module which can be inserted and removed while the kernel is 
+  running.
+
+  You will also need the latest user-space utilties: you can find them
+  in the lm_sensors package, which you can download at 
+  http://www.lm-sensors.nu
+
+National Semiconductor LM80
+CONFIG_SENSORS_LM80
+  If you say yes here you get support for National Semiconductor LM80
+  sensor chips. This can also be built as a module which can be 
+  inserted and removed while the kernel is running.
+
+  You will also need the latest user-space utilties: you can find them
+  in the lm_sensors package, which you can download at 
+  http://www.lm-sensors.nu
+
+National Semiconductor LM83
+CONFIG_SENSORS_LM83
+  If you say yes here you get support for the National Semiconductor
+  LM83 sensor chip.  This can also be built as a module.
+
+  You will also need the latest user-space utilities: you can find
+  them in the lm_sensors package, which you can download at
+  http://www.lm-sensors.nu/
+
+National Semiconductor LM85
+CONFIG_SENSORS_LM85
+  If you say yes here you get support for National Semiconductor LM85
+  sensor chips and compatibles.  Compatible chips include the Analog
+  Devices ADM1027 and ADT7463 and SMSC EMC6D100 and EMC6D101.  This
+  can also be built as a module which can be inserted and removed
+  while the kernel is running.
+
+  You will also need the latest user-space utilties: you can find them
+  in the lm_sensors package, which you can download at 
+  http://www.lm-sensors.nu
+
+National Semiconductor LM87
+CONFIG_SENSORS_LM87
+  If you say yes here you get support for National Semiconductor LM87
+  sensor chips. This can also be built as a module which can be 
+  inserted and removed while the kernel is running.
+
+  You will also need the latest user-space utilties: you can find them
+  in the lm_sensors package, which you can download at 
+  http://www.lm-sensors.nu
+
+National Semiconductor LM90
+CONFIG_SENSORS_LM90
+  If you say yes here you get support for the National Semiconductor
+  LM90, LM89 and LM99, and Analog Devices ADM1032 sensor chips.  This
+  can also be built as a module.
+
+  You will also need the latest user-space utilities: you can find
+  them in the lm_sensors package, which you can download at
+  http://www.lm-sensors.nu/
+
+National Semiconductor LM92
+CONFIG_SENSORS_LM92
+  If you say yes here you get support for National Semiconductor LM92
+  sensor chips. This can also be built as a module which can be 
+  inserted and removed while the kernel is running.
+
+  You will also need the latest user-space utilties: you can find them
+  in the lm_sensors package, which you can download at 
+  http://www.lm-sensors.nu
+
+National Semiconductor PC8736x Sensors
+CONFIG_SENSORS_PC87360
+  If you say yes here you get support for the integrated hardware
+  monitoring in the National Semicoductor PC87360, PC87363, PC87364,
+  PC87365 and PC87366 Super I/O chips. This can also be built as a
+  module which can be inserted and removed while the kernel is
+  running.
+
+  You will also need the latest user-space utilities: you can find them
+  in the lm_sensors package, which you can download at 
+  http://www.lm-sensors.nu/
+
+Philips PCF8574
+CONFIG_SENSORS_PCF8574
+  If you say yes here you get support for the Philips PCF8574
+  I2C 8-bit Parallel I/O device.
+  This can also be built as a module which can be 
+  inserted and removed while the kernel is running.
+
+  You will also need the latest user-space utilties: you can find them
+  in the lm_sensors package, which you can download at 
+  http://www.lm-sensors.nu
+
+Philips PCF8591
+CONFIG_SENSORS_PCF8591
+  If you say yes here you get support for the Philips PCF8591
+  I2C Quad D/A + Single A/D I/O device.
+  This can also be built as a module which can be 
+  inserted and removed while the kernel is running.
+
+  You will also need the latest user-space utilties: you can find them
+  in the lm_sensors package, which you can download at 
+  http://www.lm-sensors.nu
+
+Silicon Integrated Systems Corp. SiS5595 Sensor
+CONFIG_SENSORS_SIS5595
+  If you say yes here you get support for the integrated sensors in 
+  SiS5595 South Bridges. This can also be built as a module 
+  which can be inserted and removed while the kernel is running.
+
+  You will also need the latest user-space utilties: you can find them
+  in the lm_sensors package, which you can download at 
+  http://www.lm-sensors.nu
+
+SMSC47M1xx Super I/O Fan Support
+CONFIG_SENSORS_SMSC47M1
+  If you say yes here you get support for the integrated fan
+  monitoring and control in the SMSC 47M1xx Super I/O chips.
+  This can also be built as a module 
+  which can be inserted and removed while the kernel is running.
+
+  You will also need the latest user-space utilties: you can find them
+  in the lm_sensors package, which you can download at 
+  http://www.lm-sensors.nu
+
+Texas Instruments THMC50 / Analog Devices ADM1022
+CONFIG_SENSORS_THMC50
+  If you say yes here you get support for Texas Instruments THMC50
+  sensor chips and clones: the Analog Devices ADM1022.
+  This can also be built as a module which
+  can be inserted and removed while the kernel is running.
+
+  You will also need the latest user-space utilties: you can find them
+  in the lm_sensors package, which you can download at 
+  http://www.lm-sensors.nu
+
+Via VT82C686A/B
+CONFIG_SENSORS_VIA686A
+  If you say yes here you get support for the integrated sensors in 
+  Via 686A/B South Bridges. This can also be built as a module 
+  which can be inserted and removed while the kernel is running.
+
+  You will also need the latest user-space utilties: you can find them
+  in the lm_sensors package, which you can download at 
+  http://www.lm-sensors.nu
+
+Via VT1211 Sensors
+CONFIG_SENSORS_VT1211
+  If you say yes here you get support for the integrated sensors in 
+  the Via VT1211 Super I/O device. This can also be built as a module 
+  which can be inserted and removed while the kernel is running.
+
+  You will also need the latest user-space utilties: you can find them
+  in the lm_sensors package, which you can download at 
+  http://www.lm-sensors.nu
+
+Via VT8231 Sensors
+CONFIG_SENSORS_VT8231
+  If you say yes here you get support for the integrated sensors in 
+  the Via VT8231 device. This can also be built as a module 
+  which can be inserted and removed while the kernel is running.
+
+  You will also need the latest user-space utilties: you can find them
+  in the lm_sensors package, which you can download at 
+  http://www.lm-sensors.nu
+
+Winbond W83781D, W83782D, W83783S, W83627HF, AS99127F
+CONFIG_SENSORS_W83781D
+  If you say yes here you get support for the Winbond W8378x series 
+  of sensor chips: the W83781D, W83782D, W83783S and W83682HF,
+  and the similar Asus AS99127F. This
+  can also be built as a module which can be inserted and removed
+  while the kernel is running.
+
+  You will also need the latest user-space utilties: you can find them
+  in the lm_sensors package, which you can download at 
+  http://www.lm-sensors.nu
+
+Winbond W83627HF, W83627THF, W83697HF
+CONFIG_SENSORS_W83627HF
+  If you say yes here you get support for the Winbond W836x7 series 
+  of sensor chips: the Winbond W83627HF, W83627THF and W83697HF. This
+  can also be built as a module which can be inserted and removed
+  while the kernel is running.
+
+  You will also need the latest user-space utilities: you can find
+  them in the lm_sensors package, which you can download at
+  http://www.lm-sensors.nu/
+
+Winbond W83L785TS-S
+CONFIG_SENSORS_W83L785TS
+  If you say yes here you get support for the Winbond W83L785TS-S
+  sensor chip.  This can also be built as a module.
+
+  You will also need the latest user-space utilities: you can find
+  them in the lm_sensors package, which you can download at
+  http://www.lm-sensors.nu/
+
+EEprom (DIMM) reader
+CONFIG_SENSORS_EEPROM
+  If you say yes here you get read-only access to the EEPROM data 
+  available on modern memory DIMMs, and which could theoretically
+  also be available on other devices. This can also be built as a 
+  module which can be inserted and removed while the kernel is 
+  running.
+
+  You will also need the latest user-space utilties: you can find them
+  in the lm_sensors package, which you can download at 
+  http://www.lm-sensors.nu
+
 # End:
--- linux-old/MAINTAINERS       Sun Oct  3 01:33:28 2004
+++ linux/MAINTAINERS   Mon Dec 13 20:18:56 2004
@@ -1659,6 +1659,15 @@
 L:     linux-ide@vger.kernel.org
 S:     Supported
 
+SENSORS DRIVERS
+P:      Frodo Looijaard
+M:      frodol@dds.nl
+P:      Philip Edelbrock
+M:      phil@netroedge.com
+L:      sensors@stimpy.netroedge.com
+W:      http://www.lm-sensors.nu/
+S:      Maintained
+
 SGI VISUAL WORKSTATION 320 AND 540
 P:     Bent Hagemark
 M:     bh@sgi.com
--- linux-old/arch/i386/kernel/dmi_scan.c       Fri Apr 16 03:14:11 2004
+++ linux/arch/i386/kernel/dmi_scan.c   Mon Dec 13 20:18:56 2004
@@ -15,6 +15,7 @@
 #include "pci-i386.h"
 
 unsigned long dmi_broken;
+int is_unsafe_smbus;
 int is_sony_vaio_laptop;
 
 struct dmi_header
@@ -371,6 +372,19 @@
 }              
 
 /*
+ * Don't access SMBus on IBM systems which get corrupted eeproms 
+ */
+
+static __init int disable_smbus(struct dmi_blacklist *d)
+{   
+       if (is_unsafe_smbus == 0) {
+               is_unsafe_smbus = 1;
+               printk(KERN_INFO "%s machine detected. Disabling SMBus accesses.\n", d->ident);
+       }
+       return 0;
+}
+
+/*
  * Check for a Sony Vaio system
  *
  * On a Sony system we want to enable the use of the sonypi
@@ -675,6 +689,10 @@
                        NO_MATCH, NO_MATCH,
                        } },
 
+       { disable_smbus, "IBM", {
+                       MATCH(DMI_SYS_VENDOR, "IBM"),
+                       NO_MATCH, NO_MATCH, NO_MATCH
+                       } },
        { sony_vaio_laptop, "Sony Vaio", { /* This is a Sony Vaio laptop */
                        MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
                        MATCH(DMI_PRODUCT_NAME, "PCG-"),
--- linux-old/arch/i386/kernel/i386_ksyms.c     Fri Apr 16 03:14:11 2004
+++ linux/arch/i386/kernel/i386_ksyms.c Mon Dec 13 20:18:56 2004
@@ -179,6 +179,9 @@
 EXPORT_SYMBOL(atomic_dec_and_lock);
 #endif
 
+extern int is_unsafe_smbus;
+EXPORT_SYMBOL(is_unsafe_smbus);
+
 extern int is_sony_vaio_laptop;
 EXPORT_SYMBOL(is_sony_vaio_laptop);