32 files changed, 601 insertions, 102 deletions

diff --git a/drivers/i2c/busses/Kconfig b/drivers/i2c/busses/Kconfig
index 9367c4cfe936..4d44a2db29dd 100644
--- a/drivers/i2c/busses/Kconfig
+++ b/drivers/i2c/busses/Kconfig
@@ -183,6 +183,7 @@ config I2C_PIIX4
             ATI IXP200
             ATI IXP300
             ATI IXP400
+            ATI SB600
             Serverworks OSB4
             Serverworks CSB5
             Serverworks CSB6
@@ -341,6 +342,13 @@ config I2C_PARPORT_LIGHT
           This support is also available as a module.  If so, the module 
           will be called i2c-parport-light.
 
+config I2C_PASEMI
+        tristate "PA Semi SMBus interface"
+#       depends on PPC_PASEMI && I2C && PCI
+        depends on I2C && PCI
+        help
+          Supports the PA Semi PWRficient on-chip SMBus interfaces.
+
 config I2C_PROSAVAGE
         tristate "S3/VIA (Pro)Savage"
         depends on I2C && PCI
@@ -499,11 +507,11 @@ config I2C_VIA
           will be called i2c-via.
 
 config I2C_VIAPRO
-        tristate "VIA 82C596/82C686/82xx"
+        tristate "VIA VT82C596/82C686/82xx and CX700"
         depends on I2C && PCI
         help
           If you say yes to this option, support will be included for the VIA
-          82C596/82C686/82xx I2C interfaces.  Specifically, the following
+          VT82C596 and later SMBus interface.  Specifically, the following
           chipsets are supported:
             VT82C596A/B
             VT82C686A/B
@@ -512,6 +520,7 @@ config I2C_VIAPRO
             VT8235
             VT8237R/A
             VT8251
+            CX700
 
           This driver can also be built as a module.  If so, the module
           will be called i2c-viapro.
diff --git a/drivers/i2c/busses/Makefile b/drivers/i2c/busses/Makefile
index 37196c1d0794..03505aa44bbf 100644
--- a/drivers/i2c/busses/Makefile
+++ b/drivers/i2c/busses/Makefile
@@ -27,6 +27,7 @@ obj-$(CONFIG_I2C_OCORES)	+= i2c-ocores.o
 obj-$(CONFIG_I2C_OMAP)          += i2c-omap.o
 obj-$(CONFIG_I2C_PARPORT)       += i2c-parport.o
 obj-$(CONFIG_I2C_PARPORT_LIGHT) += i2c-parport-light.o
+obj-$(CONFIG_I2C_PASEMI)        += i2c-pasemi.o
 obj-$(CONFIG_I2C_PCA_ISA)       += i2c-pca-isa.o
 obj-$(CONFIG_I2C_PIIX4)         += i2c-piix4.o
 obj-$(CONFIG_I2C_PNX)           += i2c-pnx.o
diff --git a/drivers/i2c/busses/i2c-ali1535.c b/drivers/i2c/busses/i2c-ali1535.c
index e75d339a3481..6fd8ad7faa06 100644
--- a/drivers/i2c/busses/i2c-ali1535.c
+++ b/drivers/i2c/busses/i2c-ali1535.c
@@ -57,7 +57,6 @@
 #include <linux/pci.h>
 #include <linux/kernel.h>
 #include <linux/stddef.h>
-#include <linux/sched.h>
 #include <linux/delay.h>
 #include <linux/ioport.h>
 #include <linux/i2c.h>
@@ -475,6 +474,7 @@ static const struct i2c_algorithm smbus_algorithm = {
 
 static struct i2c_adapter ali1535_adapter = {
         .owner          = THIS_MODULE,
+        .id             = I2C_HW_SMBUS_ALI1535,
         .class          = I2C_CLASS_HWMON,
         .algo           = &smbus_algorithm,
 };
diff --git a/drivers/i2c/busses/i2c-ali1563.c b/drivers/i2c/busses/i2c-ali1563.c
index 8e1e3f8e40a4..6b68074e518a 100644
--- a/drivers/i2c/busses/i2c-ali1563.c
+++ b/drivers/i2c/busses/i2c-ali1563.c
@@ -314,35 +314,11 @@ static u32 ali1563_func(struct i2c_adapter * a)
 }
 
 
-static void ali1563_enable(struct pci_dev * dev)
-{
-        u16 ctrl;
-
-        pci_read_config_word(dev,ALI1563_SMBBA,&ctrl);
-        ctrl |= 0x7;
-        pci_write_config_word(dev,ALI1563_SMBBA,ctrl);
-}
-
 static int __devinit ali1563_setup(struct pci_dev * dev)
 {
         u16 ctrl;
 
         pci_read_config_word(dev,ALI1563_SMBBA,&ctrl);
-        printk("ali1563: SMBus control = %04x\n",ctrl);
-
-        /* Check if device is even enabled first */
-        if (!(ctrl & ALI1563_SMB_IOEN)) {
-                dev_warn(&dev->dev,"I/O space not enabled, trying manually\n");
-                ali1563_enable(dev);
-        }
-        if (!(ctrl & ALI1563_SMB_IOEN)) {
-                dev_warn(&dev->dev,"I/O space still not enabled, giving up\n");
-                goto Err;
-        }
-        if (!(ctrl & ALI1563_SMB_HOSTEN)) {
-                dev_warn(&dev->dev,"Host Controller not enabled\n");
-                goto Err;
-        }
 
         /* SMB I/O Base in high 12 bits and must be aligned with the
          * size of the I/O space. */
@@ -351,11 +327,31 @@ static int __devinit ali1563_setup(struct pci_dev * dev)
                 dev_warn(&dev->dev,"ali1563_smba Uninitialized\n");
                 goto Err;
         }
+
+        /* Check if device is enabled */
+        if (!(ctrl & ALI1563_SMB_HOSTEN)) {
+                dev_warn(&dev->dev, "Host Controller not enabled\n");
+                goto Err;
+        }
+        if (!(ctrl & ALI1563_SMB_IOEN)) {
+                dev_warn(&dev->dev, "I/O space not enabled, trying manually\n");
+                pci_write_config_word(dev, ALI1563_SMBBA,
+                                      ctrl | ALI1563_SMB_IOEN);
+                pci_read_config_word(dev, ALI1563_SMBBA, &ctrl);
+                if (!(ctrl & ALI1563_SMB_IOEN)) {
+                        dev_err(&dev->dev, "I/O space still not enabled, "
+                                "giving up\n");
+                        goto Err;
+                }
+        }
+
         if (!request_region(ali1563_smba, ALI1563_SMB_IOSIZE,
                             ali1563_pci_driver.name)) {
-                dev_warn(&dev->dev,"Could not allocate I/O space");
+                dev_err(&dev->dev, "Could not allocate I/O space at 0x%04x\n",
+                        ali1563_smba);
                 goto Err;
         }
+        dev_info(&dev->dev, "Found ALi1563 SMBus at 0x%04x\n", ali1563_smba);
 
         return 0;
 Err:
@@ -374,6 +370,7 @@ static const struct i2c_algorithm ali1563_algorithm = {
 
 static struct i2c_adapter ali1563_adapter = {
         .owner  = THIS_MODULE,
+        .id     = I2C_HW_SMBUS_ALI1563,
         .class  = I2C_CLASS_HWMON,
         .algo   = &ali1563_algorithm,
 };
@@ -384,13 +381,18 @@ static int __devinit ali1563_probe(struct pci_dev * dev,
         int error;
 
         if ((error = ali1563_setup(dev)))
-                return error;
+                goto exit;
         ali1563_adapter.dev.parent = &dev->dev;
         sprintf(ali1563_adapter.name,"SMBus ALi 1563 Adapter @ %04x",
                 ali1563_smba);
         if ((error = i2c_add_adapter(&ali1563_adapter)))
-                ali1563_shutdown(dev);
-        printk("%s: Returning %d\n",__FUNCTION__,error);
+                goto exit_shutdown;
+        return 0;
+
+exit_shutdown:
+        ali1563_shutdown(dev);
+exit:
+        dev_warn(&dev->dev, "ALi1563 SMBus probe failed (%d)\n", error);
         return error;
 }
 
diff --git a/drivers/i2c/busses/i2c-ali15x3.c b/drivers/i2c/busses/i2c-ali15x3.c
index 3f11b6e1a341..e4e0df106812 100644
--- a/drivers/i2c/busses/i2c-ali15x3.c
+++ b/drivers/i2c/busses/i2c-ali15x3.c
@@ -64,7 +64,6 @@
 #include <linux/pci.h>
 #include <linux/kernel.h>
 #include <linux/stddef.h>
-#include <linux/sched.h>
 #include <linux/ioport.h>
 #include <linux/delay.h>
 #include <linux/i2c.h>
@@ -470,6 +469,7 @@ static const struct i2c_algorithm smbus_algorithm = {
 
 static struct i2c_adapter ali15x3_adapter = {
         .owner          = THIS_MODULE,
+        .id             = I2C_HW_SMBUS_ALI15X3,
         .class          = I2C_CLASS_HWMON,
         .algo           = &smbus_algorithm,
 };
diff --git a/drivers/i2c/busses/i2c-amd756-s4882.c b/drivers/i2c/busses/i2c-amd756-s4882.c
index 08e915730caf..e5e96c817566 100644
--- a/drivers/i2c/busses/i2c-amd756-s4882.c
+++ b/drivers/i2c/busses/i2c-amd756-s4882.c
@@ -184,12 +184,14 @@ static int __init amd756_s4882_init(void)
         s4882_algo[0].smbus_xfer = amd756_access_virt0;
         s4882_adapter[0] = amd756_smbus;
         s4882_adapter[0].algo = s4882_algo;
+        s4882_adapter[0].dev.parent = amd756_smbus.dev.parent;
         for (i = 1; i < 5; i++) {
                 s4882_algo[i] = *(amd756_smbus.algo);
                 s4882_adapter[i] = amd756_smbus;
                 sprintf(s4882_adapter[i].name,
                         "SMBus 8111 adapter (CPU%d)", i-1);
                 s4882_adapter[i].algo = s4882_algo+i;
+                s4882_adapter[i].dev.parent = amd756_smbus.dev.parent;
         }
         s4882_algo[1].smbus_xfer = amd756_access_virt1;
         s4882_algo[2].smbus_xfer = amd756_access_virt2;
diff --git a/drivers/i2c/busses/i2c-amd756.c b/drivers/i2c/busses/i2c-amd756.c
index 2d21afdc5b1c..fa6155a54cc3 100644
--- a/drivers/i2c/busses/i2c-amd756.c
+++ b/drivers/i2c/busses/i2c-amd756.c
@@ -42,7 +42,6 @@
 #include <linux/kernel.h>
 #include <linux/delay.h>
 #include <linux/stddef.h>
-#include <linux/sched.h>
 #include <linux/ioport.h>
 #include <linux/i2c.h>
 #include <linux/init.h>
@@ -301,6 +300,7 @@ static const struct i2c_algorithm smbus_algorithm = {
 
 struct i2c_adapter amd756_smbus = {
         .owner          = THIS_MODULE,
+        .id             = I2C_HW_SMBUS_AMD756,
         .class          = I2C_CLASS_HWMON,
         .algo           = &smbus_algorithm,
 };
diff --git a/drivers/i2c/busses/i2c-amd8111.c b/drivers/i2c/busses/i2c-amd8111.c
index 0fbc7186c91a..5bba3fb50d71 100644
--- a/drivers/i2c/busses/i2c-amd8111.c
+++ b/drivers/i2c/busses/i2c-amd8111.c
@@ -12,7 +12,6 @@
 #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>
@@ -76,7 +75,8 @@ static unsigned int amd_ec_wait_write(struct amd_smbus *smbus)
                 udelay(1);
 
         if (!timeout) {
-                dev_warn(&smbus->dev->dev, "Timeout while waiting for IBF to clear\n");
+                dev_warn(&smbus->dev->dev,
+                         "Timeout while waiting for IBF to clear\n");
                 return -1;
         }
 
@@ -91,14 +91,16 @@ static unsigned int amd_ec_wait_read(struct amd_smbus *smbus)
                 udelay(1);
 
         if (!timeout) {
-                dev_warn(&smbus->dev->dev, "Timeout while waiting for OBF to set\n");
+                dev_warn(&smbus->dev->dev,
+                         "Timeout while waiting for OBF to set\n");
                 return -1;
         }
 
         return 0;
 }
 
-static unsigned int amd_ec_read(struct amd_smbus *smbus, unsigned char address, unsigned char *data)
+static unsigned int amd_ec_read(struct amd_smbus *smbus, unsigned char address,
+                unsigned char *data)
 {
         if (amd_ec_wait_write(smbus))
                 return -1;
@@ -115,7 +117,8 @@ static unsigned int amd_ec_read(struct amd_smbus *smbus, unsigned char address,
         return 0;
 }
 
-static unsigned int amd_ec_write(struct amd_smbus *smbus, unsigned char address, unsigned char data)
+static unsigned int amd_ec_write(struct amd_smbus *smbus, unsigned char address,
+                unsigned char data)
 {
         if (amd_ec_wait_write(smbus))
                 return -1;
@@ -175,18 +178,19 @@ static unsigned int amd_ec_write(struct amd_smbus *smbus, unsigned char address,
 #define AMD_SMB_PRTCL_PEC               0x80
 
 
-static s32 amd8111_access(struct i2c_adapter * adap, u16 addr, unsigned short flags,
-                char read_write, u8 command, int size, union i2c_smbus_data * data)
+static 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;
+        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;
@@ -208,8 +212,10 @@ static s32 amd8111_access(struct i2c_adapter * adap, u16 addr, unsigned short fl
                 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);
+                                amd_ec_write(smbus, AMD_SMB_DATA,
+                                             data->word & 0xff);
+                                amd_ec_write(smbus, AMD_SMB_DATA + 1,
+                                             data->word >> 8);
                         }
                         protocol |= AMD_SMB_PRTCL_WORD_DATA | pec;
                         break;
@@ -217,27 +223,31 @@ static s32 amd8111_access(struct i2c_adapter * adap, u16 addr, unsigned short fl
                 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);
+                                len = min_t(u8, data->block[0],
+                                            I2C_SMBUS_BLOCK_MAX);
                                 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]);
+                                        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);
+                        len = min_t(u8, data->block[0],
+                                    I2C_SMBUS_BLOCK_MAX);
                         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]);
+                                        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, data->word & 0xff);
                         amd_ec_write(smbus, AMD_SMB_DATA + 1, data->word >> 8);
                         protocol = AMD_SMB_PRTCL_PROC_CALL | pec;
                         read_write = I2C_SMBUS_READ;
@@ -248,7 +258,8 @@ static s32 amd8111_access(struct i2c_adapter * adap, u16 addr, unsigned short fl
                         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]);
+                                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;
@@ -280,7 +291,6 @@ static s32 amd8111_access(struct i2c_adapter * adap, u16 addr, unsigned short fl
                 return 0;
 
         switch (size) {
-
                 case I2C_SMBUS_BYTE:
                 case I2C_SMBUS_BYTE_DATA:
                         amd_ec_read(smbus, AMD_SMB_DATA, &data->byte);
@@ -296,10 +306,11 @@ static s32 amd8111_access(struct i2c_adapter * adap, u16 addr, unsigned short fl
                 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);
+                        len = min_t(u8, len, I2C_SMBUS_BLOCK_MAX);
                 case I2C_SMBUS_I2C_BLOCK_DATA:
                         for (i = 0; i < len; i++)
-                                amd_ec_read(smbus, AMD_SMB_DATA + i, data->block + i + 1);
+                                amd_ec_read(smbus, AMD_SMB_DATA + i,
+                                            data->block + i + 1);
                         data->block[0] = len;
                         break;
         }
@@ -310,7 +321,8 @@ static s32 amd8111_access(struct i2c_adapter * adap, u16 addr, unsigned short fl
 
 static u32 amd8111_func(struct i2c_adapter *adapter)
 {
-        return  I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE | I2C_FUNC_SMBUS_BYTE_DATA |
+        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;
@@ -329,12 +341,13 @@ static struct pci_device_id amd8111_ids[] = {
 
 MODULE_DEVICE_TABLE (pci, amd8111_ids);
 
-static int __devinit amd8111_probe(struct pci_dev *dev, const struct pci_device_id *id)
+static int __devinit amd8111_probe(struct pci_dev *dev,
+                const struct pci_device_id *id)
 {
         struct amd_smbus *smbus;
-        int error = -ENODEV;
+        int error;
 
-        if (~pci_resource_flags(dev, 0) & IORESOURCE_IO)
+        if (!(pci_resource_flags(dev, 0) & IORESOURCE_IO))
                 return -ENODEV;
 
         smbus = kzalloc(sizeof(struct amd_smbus), GFP_KERNEL);
@@ -345,12 +358,15 @@ static int __devinit amd8111_probe(struct pci_dev *dev, const struct pci_device_
         smbus->base = pci_resource_start(dev, 0);
         smbus->size = pci_resource_len(dev, 0);
 
-        if (!request_region(smbus->base, smbus->size, amd8111_driver.name))
+        if (!request_region(smbus->base, smbus->size, amd8111_driver.name)) {
+                error = -EBUSY;
                 goto out_kfree;
+        }
 
         smbus->adapter.owner = THIS_MODULE;
         snprintf(smbus->adapter.name, I2C_NAME_SIZE,
                 "SMBus2 AMD8111 adapter at %04x", smbus->base);
+        smbus->adapter.id = I2C_HW_SMBUS_AMD8111;
         smbus->adapter.class = I2C_CLASS_HWMON;
         smbus->adapter.algo = &smbus_algorithm;
         smbus->adapter.algo_data = smbus;
@@ -358,11 +374,11 @@ static int __devinit amd8111_probe(struct pci_dev *dev, const struct pci_device_
         /* set up the driverfs linkage to our parent device */
         smbus->adapter.dev.parent = &dev->dev;
 
+        pci_write_config_dword(smbus->dev, AMD_PCI_MISC, 0);
         error = i2c_add_adapter(&smbus->adapter);
         if (error)
                 goto out_release_region;
 
-        pci_write_config_dword(smbus->dev, AMD_PCI_MISC, 0);
         pci_set_drvdata(dev, smbus);
         return 0;
 
@@ -370,10 +386,9 @@ static int __devinit amd8111_probe(struct pci_dev *dev, const struct pci_device_
         release_region(smbus->base, smbus->size);
  out_kfree:
         kfree(smbus);
-        return -1;
+        return error;
 }
 
-
 static void __devexit amd8111_remove(struct pci_dev *dev)
 {
         struct amd_smbus *smbus = pci_get_drvdata(dev);
@@ -395,7 +410,6 @@ static int __init i2c_amd8111_init(void)
         return pci_register_driver(&amd8111_driver);
 }
 
-
 static void __exit i2c_amd8111_exit(void)
 {
         pci_unregister_driver(&amd8111_driver);
diff --git a/drivers/i2c/busses/i2c-i801.c b/drivers/i2c/busses/i2c-i801.c
index ae625b854470..21f2671f7220 100644
--- a/drivers/i2c/busses/i2c-i801.c
+++ b/drivers/i2c/busses/i2c-i801.c
@@ -48,7 +48,6 @@
 #include <linux/kernel.h>
 #include <linux/stddef.h>
 #include <linux/delay.h>
-#include <linux/sched.h>
 #include <linux/ioport.h>
 #include <linux/init.h>
 #include <linux/i2c.h>
@@ -123,7 +122,7 @@ static int i801_transaction(void)
                         dev_dbg(&I801_dev->dev, "Failed! (%02x)\n", temp);
                         return -1;
                 } else {
-                        dev_dbg(&I801_dev->dev, "Successfull!\n");
+                        dev_dbg(&I801_dev->dev, "Successful!\n");
                 }
         }
 
@@ -442,6 +441,7 @@ static const struct i2c_algorithm smbus_algorithm = {
 
 static struct i2c_adapter i801_adapter = {
         .owner          = THIS_MODULE,
+        .id             = I2C_HW_SMBUS_I801,
         .class          = I2C_CLASS_HWMON,
         .algo           = &smbus_algorithm,
 };
diff --git a/drivers/i2c/busses/i2c-i810.c b/drivers/i2c/busses/i2c-i810.c
index 10c98bc88aa6..42e8d94c276f 100644
--- a/drivers/i2c/busses/i2c-i810.c
+++ b/drivers/i2c/busses/i2c-i810.c
@@ -171,6 +171,7 @@ static struct i2c_algo_bit_data i810_i2c_bit_data = {
 
 static struct i2c_adapter i810_i2c_adapter = {
         .owner          = THIS_MODULE,
+        .id             = I2C_HW_B_I810,
         .name           = "I810/I815 I2C Adapter",
         .algo_data      = &i810_i2c_bit_data,
 };
@@ -186,6 +187,7 @@ static struct i2c_algo_bit_data i810_ddc_bit_data = {
 
 static struct i2c_adapter i810_ddc_adapter = {
         .owner          = THIS_MODULE,
+        .id             = I2C_HW_B_I810,
         .name           = "I810/I815 DDC Adapter",
         .algo_data      = &i810_ddc_bit_data,
 };
diff --git a/drivers/i2c/busses/i2c-ibm_iic.c b/drivers/i2c/busses/i2c-ibm_iic.c
index 1898e9987021..8b14d14e60ca 100644
--- a/drivers/i2c/busses/i2c-ibm_iic.c
+++ b/drivers/i2c/busses/i2c-ibm_iic.c
@@ -727,6 +727,7 @@ static int __devinit iic_probe(struct ocp_device *ocp){
         
         /* Register it with i2c layer */
         adap = &dev->adap;
+        adap->dev.parent = &ocp->dev;
         strcpy(adap->name, "IBM IIC");
         i2c_set_adapdata(adap, dev);
         adap->id = I2C_HW_OCP;
diff --git a/drivers/i2c/busses/i2c-iop3xx.c b/drivers/i2c/busses/i2c-iop3xx.c
index d108ab4974cc..20ee4f7c53a0 100644
--- a/drivers/i2c/busses/i2c-iop3xx.c
+++ b/drivers/i2c/busses/i2c-iop3xx.c
@@ -36,7 +36,6 @@
 #include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/errno.h>
-#include <linux/sched.h>
 #include <linux/platform_device.h>
 #include <linux/i2c.h>
 
diff --git a/drivers/i2c/busses/i2c-isa.c b/drivers/i2c/busses/i2c-isa.c
index 8ed59a2dff53..5f33bc9c1e02 100644
--- a/drivers/i2c/busses/i2c-isa.c
+++ b/drivers/i2c/busses/i2c-isa.c
@@ -39,6 +39,7 @@
 #include <linux/i2c.h>
 #include <linux/i2c-isa.h>
 #include <linux/platform_device.h>
+#include <linux/completion.h>
 
 static u32 isa_func(struct i2c_adapter *adapter);
 
diff --git a/drivers/i2c/busses/i2c-mv64xxx.c b/drivers/i2c/busses/i2c-mv64xxx.c
index 490173611d6b..a3283b907eb8 100644
--- a/drivers/i2c/busses/i2c-mv64xxx.c
+++ b/drivers/i2c/busses/i2c-mv64xxx.c
@@ -520,6 +520,7 @@ mv64xxx_i2c_probe(struct platform_device *pd)
                 rc = -ENXIO;
                 goto exit_unmap_regs;
         }
+        drv_data->adapter.dev.parent = &pd->dev;
         drv_data->adapter.id = I2C_HW_MV64XXX;
         drv_data->adapter.algo = &mv64xxx_i2c_algo;
         drv_data->adapter.owner = THIS_MODULE;
diff --git a/drivers/i2c/busses/i2c-nforce2.c b/drivers/i2c/busses/i2c-nforce2.c
index ad37c10e7fec..1514ec5b77f8 100644
--- a/drivers/i2c/busses/i2c-nforce2.c
+++ b/drivers/i2c/busses/i2c-nforce2.c
@@ -44,7 +44,6 @@
 #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>
@@ -57,7 +56,6 @@ MODULE_DESCRIPTION("nForce2/3/4/5xx SMBus driver");
 
 
 struct nforce2_smbus {
-        struct pci_dev *dev;
         struct i2c_adapter adapter;
         int base;
         int size;
@@ -230,7 +228,6 @@ static int __devinit nforce2_probe_smb (struct pci_dev *dev, int bar,
                 smbus->base = iobase & PCI_BASE_ADDRESS_IO_MASK;
                 smbus->size = 64;
         }
-        smbus->dev = dev;
 
         if (!request_region(smbus->base, smbus->size, nforce2_driver.name)) {
                 dev_err(&smbus->adapter.dev, "Error requesting region %02x .. %02X for %s\n",
@@ -238,6 +235,7 @@ static int __devinit nforce2_probe_smb (struct pci_dev *dev, int bar,
                 return -1;
         }
         smbus->adapter.owner = THIS_MODULE;
+        smbus->adapter.id = I2C_HW_SMBUS_NFORCE2;
         smbus->adapter.class = I2C_CLASS_HWMON;
         smbus->adapter.algo = &smbus_algorithm;
         smbus->adapter.algo_data = smbus;
diff --git a/drivers/i2c/busses/i2c-ocores.c b/drivers/i2c/busses/i2c-ocores.c
index f28a76d1c0af..e417c2c3ca22 100644
--- a/drivers/i2c/busses/i2c-ocores.c
+++ b/drivers/i2c/busses/i2c-ocores.c
@@ -11,7 +11,6 @@
 
 #include <linux/kernel.h>
 #include <linux/module.h>
-#include <linux/sched.h>
 #include <linux/init.h>
 #include <linux/errno.h>
 #include <linux/platform_device.h>
diff --git a/drivers/i2c/busses/i2c-parport.h b/drivers/i2c/busses/i2c-parport.h
index 9ddd816d5d0f..ed69d846cb95 100644
--- a/drivers/i2c/busses/i2c-parport.h
+++ b/drivers/i2c/busses/i2c-parport.h
@@ -88,6 +88,13 @@ static struct adapter_parm adapter_parm[] = {
                 .getscl = { 0x40, STAT, 0 },
                 .init   = { 0xfc, DATA, 0 },
         },
+        /* type 7: One For All JP1 parallel port adapter */
+        {
+                .setsda = { 0x01, DATA, 0 },
+                .setscl = { 0x02, DATA, 0 },
+                .getsda = { 0x80, STAT, 1 },
+                .init   = { 0x04, DATA, 1 },
+        },
 };
 
 static int type = -1;
@@ -101,4 +108,5 @@ MODULE_PARM_DESC(type,
         " 4 = ADM1032 evaluation board\n"
         " 5 = ADM1025, ADM1030 and ADM1031 evaluation boards\n"
         " 6 = Barco LPT->DVI (K5800236) adapter\n"
+        " 7 = One For All JP1 parallel port adapter\n"
 );
diff --git a/drivers/i2c/busses/i2c-pasemi.c b/drivers/i2c/busses/i2c-pasemi.c
new file mode 100644
index 000000000000..f54fb5d65cc4
--- /dev/null
+++ b/drivers/i2c/busses/i2c-pasemi.c
@@ -0,0 +1,426 @@
+/*
+ * Copyright (C) 2006-2007 PA Semi, Inc
+ *
+ * SMBus host driver for PA Semi PWRficient
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ */
+
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/kernel.h>
+#include <linux/stddef.h>
+#include <linux/sched.h>
+#include <linux/i2c.h>
+#include <linux/delay.h>
+#include <asm/io.h>
+
+static struct pci_driver pasemi_smb_driver;
+
+struct pasemi_smbus {
+        struct pci_dev          *dev;
+        struct i2c_adapter       adapter;
+        unsigned long            base;
+        int                      size;
+};
+
+/* Register offsets */
+#define REG_MTXFIFO     0x00
+#define REG_MRXFIFO     0x04
+#define REG_SMSTA       0x14
+#define REG_CTL         0x1c
+
+/* Register defs */
+#define MTXFIFO_READ    0x00000400
+#define MTXFIFO_STOP    0x00000200
+#define MTXFIFO_START   0x00000100
+#define MTXFIFO_DATA_M  0x000000ff
+
+#define MRXFIFO_EMPTY   0x00000100
+#define MRXFIFO_DATA_M  0x000000ff
+
+#define SMSTA_XEN       0x08000000
+
+#define CTL_MRR         0x00000400
+#define CTL_MTR         0x00000200
+#define CTL_CLK_M       0x000000ff
+
+#define CLK_100K_DIV    84
+#define CLK_400K_DIV    21
+
+static inline void reg_write(struct pasemi_smbus *smbus, int reg, int val)
+{
+        dev_dbg(&smbus->dev->dev, "smbus write reg %lx val %08x\n",
+                smbus->base + reg, val);
+        outl(val, smbus->base + reg);
+}
+
+static inline int reg_read(struct pasemi_smbus *smbus, int reg)
+{
+        int ret;
+        ret = inl(smbus->base + reg);
+        dev_dbg(&smbus->dev->dev, "smbus read reg %lx val %08x\n",
+                smbus->base + reg, ret);
+        return ret;
+}
+
+#define TXFIFO_WR(smbus, reg)   reg_write((smbus), REG_MTXFIFO, (reg))
+#define RXFIFO_RD(smbus)        reg_read((smbus), REG_MRXFIFO)
+
+static void pasemi_smb_clear(struct pasemi_smbus *smbus)
+{
+        unsigned int status;
+
+        status = reg_read(smbus, REG_SMSTA);
+        reg_write(smbus, REG_SMSTA, status);
+}
+
+static unsigned int pasemi_smb_waitready(struct pasemi_smbus *smbus)
+{
+        int timeout = 10;
+        unsigned int status;
+
+        status = reg_read(smbus, REG_SMSTA);
+
+        while (!(status & SMSTA_XEN) && timeout--) {
+                msleep(1);
+                status = reg_read(smbus, REG_SMSTA);
+        }
+
+        if (timeout < 0) {
+                dev_warn(&smbus->dev->dev, "Timeout, status 0x%08x\n", status);
+                reg_write(smbus, REG_SMSTA, status);
+                return -ETIME;
+        }
+
+        /* Clear XEN */
+        reg_write(smbus, REG_SMSTA, SMSTA_XEN);
+
+        return 0;
+}
+
+static int pasemi_i2c_xfer_msg(struct i2c_adapter *adapter,
+                               struct i2c_msg *msg, int stop)
+{
+        struct pasemi_smbus *smbus = adapter->algo_data;
+        int read, i, err;
+        u32 rd;
+
+        read = msg->flags & I2C_M_RD ? 1 : 0;
+
+        TXFIFO_WR(smbus, MTXFIFO_START | (msg->addr << 1) | read);
+
+        if (read) {
+                TXFIFO_WR(smbus, msg->len | MTXFIFO_READ |
+                                 (stop ? MTXFIFO_STOP : 0));
+
+                err = pasemi_smb_waitready(smbus);
+                if (err)
+                        goto reset_out;
+
+                for (i = 0; i < msg->len; i++) {
+                        rd = RXFIFO_RD(smbus);
+                        if (rd & MRXFIFO_EMPTY) {
+                                err = -ENODATA;
+                                goto reset_out;
+                        }
+                        msg->buf[i] = rd & MRXFIFO_DATA_M;
+                }
+        } else {
+                for (i = 0; i < msg->len - 1; i++)
+                        TXFIFO_WR(smbus, msg->buf[i]);
+
+                TXFIFO_WR(smbus, msg->buf[msg->len] |
+                          (stop ? MTXFIFO_STOP : 0));
+        }
+
+        return 0;
+
+ reset_out:
+        reg_write(smbus, REG_CTL, (CTL_MTR | CTL_MRR |
+                  (CLK_100K_DIV & CTL_CLK_M)));
+        return err;
+}
+
+static int pasemi_i2c_xfer(struct i2c_adapter *adapter,
+                           struct i2c_msg *msgs, int num)
+{
+        struct pasemi_smbus *smbus = adapter->algo_data;
+        int ret, i;
+
+        pasemi_smb_clear(smbus);
+
+        ret = 0;
+
+        for (i = 0; i < num && !ret; i++)
+                ret = pasemi_i2c_xfer_msg(adapter, &msgs[i], (i == (num - 1)));
+
+        return ret ? ret : num;
+}
+
+static int pasemi_smb_xfer(struct i2c_adapter *adapter,
+                u16 addr, unsigned short flags, char read_write, u8 command,
+                int size, union i2c_smbus_data *data)
+{
+        struct pasemi_smbus *smbus = adapter->algo_data;
+        unsigned int rd;
+        int read_flag, err;
+        int len = 0, i;
+
+        /* All our ops take 8-bit shifted addresses */
+        addr <<= 1;
+        read_flag = read_write == I2C_SMBUS_READ;
+
+        pasemi_smb_clear(smbus);
+
+        switch (size) {
+        case I2C_SMBUS_QUICK:
+                TXFIFO_WR(smbus, addr | read_flag | MTXFIFO_START |
+                          MTXFIFO_STOP);
+                break;
+        case I2C_SMBUS_BYTE:
+                TXFIFO_WR(smbus, addr | read_flag | MTXFIFO_START);
+                if (read_write)
+                        TXFIFO_WR(smbus, 1 | MTXFIFO_STOP | MTXFIFO_READ);
+                else
+                        TXFIFO_WR(smbus, MTXFIFO_STOP | command);
+                break;
+        case I2C_SMBUS_BYTE_DATA:
+                TXFIFO_WR(smbus, addr | MTXFIFO_START);
+                TXFIFO_WR(smbus, command);
+                if (read_write) {
+                        TXFIFO_WR(smbus, addr | I2C_SMBUS_READ | MTXFIFO_START);
+                        TXFIFO_WR(smbus, 1 | MTXFIFO_READ | MTXFIFO_STOP);
+                } else {
+                        TXFIFO_WR(smbus, MTXFIFO_STOP | data->byte);
+                }
+                break;
+        case I2C_SMBUS_WORD_DATA:
+                TXFIFO_WR(smbus, addr | MTXFIFO_START);
+                TXFIFO_WR(smbus, command);
+                if (read_write) {
+                        TXFIFO_WR(smbus, addr | I2C_SMBUS_READ | MTXFIFO_START);
+                        TXFIFO_WR(smbus, 2 | MTXFIFO_READ | MTXFIFO_STOP);
+                } else {
+                        TXFIFO_WR(smbus, data->word & MTXFIFO_DATA_M);
+                        TXFIFO_WR(smbus, MTXFIFO_STOP | (data->word >> 8));
+                }
+                break;
+        case I2C_SMBUS_BLOCK_DATA:
+                TXFIFO_WR(smbus, addr | MTXFIFO_START);
+                TXFIFO_WR(smbus, command);
+                if (read_write) {
+                        TXFIFO_WR(smbus, addr | I2C_SMBUS_READ | MTXFIFO_START);
+                        TXFIFO_WR(smbus, 1 | MTXFIFO_READ);
+                        rd = RXFIFO_RD(smbus);
+                        len = min_t(u8, (rd & MRXFIFO_DATA_M),
+                                    I2C_SMBUS_BLOCK_MAX);
+                        TXFIFO_WR(smbus, (len + 1) | MTXFIFO_READ |
+                                         MTXFIFO_STOP);
+                } else {
+                        len = min_t(u8, data->block[0], I2C_SMBUS_BLOCK_MAX);
+                        TXFIFO_WR(smbus, len);
+                        for (i = 1; i < len; i++)
+                                TXFIFO_WR(smbus, data->block[i]);
+                        TXFIFO_WR(smbus, data->block[len] | MTXFIFO_STOP);
+                }
+                break;
+        case I2C_SMBUS_PROC_CALL:
+                read_write = I2C_SMBUS_READ;
+                TXFIFO_WR(smbus, addr | MTXFIFO_START);
+                TXFIFO_WR(smbus, command);
+                TXFIFO_WR(smbus, data->word & MTXFIFO_DATA_M);
+                TXFIFO_WR(smbus, (data->word >> 8) & MTXFIFO_DATA_M);
+                TXFIFO_WR(smbus, addr | I2C_SMBUS_READ | MTXFIFO_START);
+                TXFIFO_WR(smbus, 2 | MTXFIFO_STOP | MTXFIFO_READ);
+                break;
+        case I2C_SMBUS_BLOCK_PROC_CALL:
+                len = min_t(u8, data->block[0], I2C_SMBUS_BLOCK_MAX - 1);
+                read_write = I2C_SMBUS_READ;
+                TXFIFO_WR(smbus, addr | MTXFIFO_START);
+                TXFIFO_WR(smbus, command);
+                TXFIFO_WR(smbus, len);
+                for (i = 1; i <= len; i++)
+                        TXFIFO_WR(smbus, data->block[i]);
+                TXFIFO_WR(smbus, addr | I2C_SMBUS_READ);
+                TXFIFO_WR(smbus, MTXFIFO_READ | 1);
+                rd = RXFIFO_RD(smbus);
+                len = min_t(u8, (rd & MRXFIFO_DATA_M),
+                            I2C_SMBUS_BLOCK_MAX - len);
+                TXFIFO_WR(smbus, (len + 1) | MTXFIFO_READ | MTXFIFO_STOP);
+                break;
+
+        default:
+                dev_warn(&adapter->dev, "Unsupported transaction %d\n", size);
+                return -EINVAL;
+        }
+
+        err = pasemi_smb_waitready(smbus);
+        if (err)
+                goto reset_out;
+
+        if (read_write == I2C_SMBUS_WRITE)
+                return 0;
+
+        switch (size) {
+        case I2C_SMBUS_BYTE:
+        case I2C_SMBUS_BYTE_DATA:
+                rd = RXFIFO_RD(smbus);
+                if (rd & MRXFIFO_EMPTY) {
+                        err = -ENODATA;
+                        goto reset_out;
+                }
+                data->byte = rd & MRXFIFO_DATA_M;
+                break;
+        case I2C_SMBUS_WORD_DATA:
+        case I2C_SMBUS_PROC_CALL:
+                rd = RXFIFO_RD(smbus);
+                if (rd & MRXFIFO_EMPTY) {
+                        err = -ENODATA;
+                        goto reset_out;
+                }
+                data->word = rd & MRXFIFO_DATA_M;
+                rd = RXFIFO_RD(smbus);
+                if (rd & MRXFIFO_EMPTY) {
+                        err = -ENODATA;
+                        goto reset_out;
+                }
+                data->word |= (rd & MRXFIFO_DATA_M) << 8;
+                break;
+        case I2C_SMBUS_BLOCK_DATA:
+        case I2C_SMBUS_BLOCK_PROC_CALL:
+                data->block[0] = len;
+                for (i = 1; i <= len; i ++) {
+                        rd = RXFIFO_RD(smbus);
+                        if (rd & MRXFIFO_EMPTY) {
+                                err = -ENODATA;
+                                goto reset_out;
+                        }
+                        data->block[i] = rd & MRXFIFO_DATA_M;
+                }
+                break;
+        }
+
+        return 0;
+
+ reset_out:
+        reg_write(smbus, REG_CTL, (CTL_MTR | CTL_MRR |
+                  (CLK_100K_DIV & CTL_CLK_M)));
+        return err;
+}
+
+static u32 pasemi_smb_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_I2C;
+}
+
+static const struct i2c_algorithm smbus_algorithm = {
+        .master_xfer    = pasemi_i2c_xfer,
+        .smbus_xfer     = pasemi_smb_xfer,
+        .functionality  = pasemi_smb_func,
+};
+
+static int __devinit pasemi_smb_probe(struct pci_dev *dev,
+                                      const struct pci_device_id *id)
+{
+        struct pasemi_smbus *smbus;
+        int error;
+
+        if (!(pci_resource_flags(dev, 0) & IORESOURCE_IO))
+                return -ENODEV;
+
+        smbus = kzalloc(sizeof(struct pasemi_smbus), GFP_KERNEL);
+        if (!smbus)
+                return -ENOMEM;
+
+        smbus->dev = dev;
+        smbus->base = pci_resource_start(dev, 0);
+        smbus->size = pci_resource_len(dev, 0);
+
+        if (!request_region(smbus->base, smbus->size,
+                            pasemi_smb_driver.name)) {
+                error = -EBUSY;
+                goto out_kfree;
+        }
+
+        smbus->adapter.owner = THIS_MODULE;
+        snprintf(smbus->adapter.name, I2C_NAME_SIZE,
+                 "PA Semi SMBus adapter at 0x%lx", smbus->base);
+        smbus->adapter.class = I2C_CLASS_HWMON;
+        smbus->adapter.algo = &smbus_algorithm;
+        smbus->adapter.algo_data = smbus;
+
+        /* set up the driverfs linkage to our parent device */
+        smbus->adapter.dev.parent = &dev->dev;
+
+        reg_write(smbus, REG_CTL, (CTL_MTR | CTL_MRR |
+                  (CLK_100K_DIV & CTL_CLK_M)));
+
+        error = i2c_add_adapter(&smbus->adapter);
+        if (error)
+                goto out_release_region;
+
+        pci_set_drvdata(dev, smbus);
+
+        return 0;
+
+ out_release_region:
+        release_region(smbus->base, smbus->size);
+ out_kfree:
+        kfree(smbus);
+        return error;
+}
+
+static void __devexit pasemi_smb_remove(struct pci_dev *dev)
+{
+        struct pasemi_smbus *smbus = pci_get_drvdata(dev);
+
+        i2c_del_adapter(&smbus->adapter);
+        release_region(smbus->base, smbus->size);
+        kfree(smbus);
+}
+
+static struct pci_device_id pasemi_smb_ids[] = {
+        { PCI_DEVICE(0x1959, 0xa003) },
+        { 0, }
+};
+
+MODULE_DEVICE_TABLE(pci, pasemi_smb_ids);
+
+static struct pci_driver pasemi_smb_driver = {
+        .name           = "i2c-pasemi",
+        .id_table       = pasemi_smb_ids,
+        .probe          = pasemi_smb_probe,
+        .remove         = __devexit_p(pasemi_smb_remove),
+};
+
+static int __init pasemi_smb_init(void)
+{
+        return pci_register_driver(&pasemi_smb_driver);
+}
+
+static void __exit pasemi_smb_exit(void)
+{
+        pci_unregister_driver(&pasemi_smb_driver);
+}
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR ("Olof Johansson <olof@lixom.net>");
+MODULE_DESCRIPTION("PA Semi PWRficient SMBus driver");
+
+module_init(pasemi_smb_init);
+module_exit(pasemi_smb_exit);
diff --git a/drivers/i2c/busses/i2c-piix4.c b/drivers/i2c/busses/i2c-piix4.c
index 30c7a1b38cbd..d888293c1a9c 100644
--- a/drivers/i2c/busses/i2c-piix4.c
+++ b/drivers/i2c/busses/i2c-piix4.c
@@ -23,6 +23,7 @@
    Supports:
         Intel PIIX4, 440MX
         Serverworks OSB4, CSB5, CSB6, HT-1000
+        ATI IXP200, IXP300, IXP400, SB600
         SMSC Victory66
 
    Note: we assume there can only be one device, with one SMBus interface.
@@ -34,7 +35,6 @@
 #include <linux/kernel.h>
 #include <linux/delay.h>
 #include <linux/stddef.h>
-#include <linux/sched.h>
 #include <linux/ioport.h>
 #include <linux/i2c.h>
 #include <linux/init.h>
@@ -383,6 +383,7 @@ static const struct i2c_algorithm smbus_algorithm = {
 
 static struct i2c_adapter piix4_adapter = {
         .owner          = THIS_MODULE,
+        .id             = I2C_HW_SMBUS_PIIX4,
         .class          = I2C_CLASS_HWMON,
         .algo           = &smbus_algorithm,
 };
@@ -396,6 +397,8 @@ static struct pci_device_id piix4_ids[] = {
           .driver_data = 0 },
         { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_IXP400_SMBUS),
           .driver_data = 0 },
+        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_IXP600_SMBUS),
+          .driver_data = 0 },
         { PCI_DEVICE(PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_OSB4),
           .driver_data = 0 },
         { PCI_DEVICE(PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_CSB5),
diff --git a/drivers/i2c/busses/i2c-powermac.c b/drivers/i2c/busses/i2c-powermac.c
index 648d55533d87..1425d2245c82 100644
--- a/drivers/i2c/busses/i2c-powermac.c
+++ b/drivers/i2c/busses/i2c-powermac.c
@@ -25,7 +25,6 @@
 #include <linux/types.h>
 #include <linux/i2c.h>
 #include <linux/init.h>
-#include <linux/completion.h>
 #include <linux/device.h>
 #include <linux/platform_device.h>
 #include <asm/prom.h>
diff --git a/drivers/i2c/busses/i2c-s3c2410.c b/drivers/i2c/busses/i2c-s3c2410.c
index 4ca6de209b8b..556f244aae76 100644
--- a/drivers/i2c/busses/i2c-s3c2410.c
+++ b/drivers/i2c/busses/i2c-s3c2410.c
@@ -28,7 +28,6 @@
 #include <linux/init.h>
 #include <linux/time.h>
 #include <linux/interrupt.h>
-#include <linux/sched.h>
 #include <linux/delay.h>
 #include <linux/errno.h>
 #include <linux/err.h>
diff --git a/drivers/i2c/busses/i2c-savage4.c b/drivers/i2c/busses/i2c-savage4.c
index 844b4ff90893..b7fb65c30112 100644
--- a/drivers/i2c/busses/i2c-savage4.c
+++ b/drivers/i2c/busses/i2c-savage4.c
@@ -145,6 +145,7 @@ static struct i2c_algo_bit_data sav_i2c_bit_data = {
 
 static struct i2c_adapter savage4_i2c_adapter = {
         .owner          = THIS_MODULE,
+        .id             = I2C_HW_B_SAVAGE,
         .name           = "I2C Savage4 adapter",
         .algo_data      = &sav_i2c_bit_data,
 };
diff --git a/drivers/i2c/busses/i2c-sis5595.c b/drivers/i2c/busses/i2c-sis5595.c
index 38bbfd840b6b..d333babe4ad3 100644
--- a/drivers/i2c/busses/i2c-sis5595.c
+++ b/drivers/i2c/busses/i2c-sis5595.c
@@ -365,6 +365,7 @@ static const struct i2c_algorithm smbus_algorithm = {
 
 static struct i2c_adapter sis5595_adapter = {
         .owner          = THIS_MODULE,
+        .id             = I2C_HW_SMBUS_SIS5595,
         .class          = I2C_CLASS_HWMON,
         .algo           = &smbus_algorithm,
 };
diff --git a/drivers/i2c/busses/i2c-sis630.c b/drivers/i2c/busses/i2c-sis630.c
index dec0bafb52ab..172bacf932a6 100644
--- a/drivers/i2c/busses/i2c-sis630.c
+++ b/drivers/i2c/busses/i2c-sis630.c
@@ -457,6 +457,7 @@ static const struct i2c_algorithm smbus_algorithm = {
 
 static struct i2c_adapter sis630_adapter = {
         .owner          = THIS_MODULE,
+        .id             = I2C_HW_SMBUS_SIS630,
         .class          = I2C_CLASS_HWMON,
         .algo           = &smbus_algorithm,
 };
diff --git a/drivers/i2c/busses/i2c-sis96x.c b/drivers/i2c/busses/i2c-sis96x.c
index 7fd07fbac336..73dae449fb23 100644
--- a/drivers/i2c/busses/i2c-sis96x.c
+++ b/drivers/i2c/busses/i2c-sis96x.c
@@ -37,7 +37,6 @@
 #include <linux/kernel.h>
 #include <linux/delay.h>
 #include <linux/stddef.h>
-#include <linux/sched.h>
 #include <linux/ioport.h>
 #include <linux/i2c.h>
 #include <linux/init.h>
@@ -249,6 +248,7 @@ static const struct i2c_algorithm smbus_algorithm = {
 
 static struct i2c_adapter sis96x_adapter = {
         .owner          = THIS_MODULE,
+        .id             = I2C_HW_SMBUS_SIS96X,
         .class          = I2C_CLASS_HWMON,
         .algo           = &smbus_algorithm,
 };
diff --git a/drivers/i2c/busses/i2c-via.c b/drivers/i2c/busses/i2c-via.c
index 15d7e00e47e6..bbcc62151f7c 100644
--- a/drivers/i2c/busses/i2c-via.c
+++ b/drivers/i2c/busses/i2c-via.c
@@ -86,6 +86,7 @@ static struct i2c_algo_bit_data bit_data = {
 
 static struct i2c_adapter vt586b_adapter = {
         .owner          = THIS_MODULE,
+        .id             = I2C_HW_B_VIA,
         .class          = I2C_CLASS_HWMON,
         .name           = "VIA i2c",
         .algo_data      = &bit_data,
diff --git a/drivers/i2c/busses/i2c-viapro.c b/drivers/i2c/busses/i2c-viapro.c
index efc6bbf0cc0a..03c5fc868548 100644
--- a/drivers/i2c/busses/i2c-viapro.c
+++ b/drivers/i2c/busses/i2c-viapro.c
@@ -4,7 +4,7 @@
     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>
-    Copyright (C) 2005  Jean Delvare <khali@linux-fr.org>
+    Copyright (C) 2005 - 2007  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
@@ -36,6 +36,7 @@
    VT8237R            0x3227             yes
    VT8237A            0x3337             yes
    VT8251             0x3287             yes
+   CX700              0x8324             yes
 
    Note: we assume there can only be one device, with one SMBus interface.
 */
@@ -306,6 +307,7 @@ static const struct i2c_algorithm smbus_algorithm = {
 
 static struct i2c_adapter vt596_adapter = {
         .owner          = THIS_MODULE,
+        .id             = I2C_HW_SMBUS_VIA2,
         .class          = I2C_CLASS_HWMON,
         .algo           = &smbus_algorithm,
 };
@@ -383,6 +385,7 @@ found:
         dev_dbg(&pdev->dev, "VT596_smba = 0x%X\n", vt596_smba);
 
         switch (pdev->device) {
+        case PCI_DEVICE_ID_VIA_CX700:
         case PCI_DEVICE_ID_VIA_8251:
         case PCI_DEVICE_ID_VIA_8237:
         case PCI_DEVICE_ID_VIA_8237A:
@@ -442,6 +445,8 @@ static struct pci_device_id vt596_ids[] = {
           .driver_data = SMBBA1 },
         { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8251),
           .driver_data = SMBBA3 },
+        { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_CX700),
+          .driver_data = SMBBA3 },
         { 0, }
 };
 
diff --git a/drivers/i2c/busses/i2c-voodoo3.c b/drivers/i2c/busses/i2c-voodoo3.c
index b0377b81744b..88a3447e11e1 100644
--- a/drivers/i2c/busses/i2c-voodoo3.c
+++ b/drivers/i2c/busses/i2c-voodoo3.c
@@ -165,6 +165,7 @@ static struct i2c_algo_bit_data voo_i2c_bit_data = {
 
 static struct i2c_adapter voodoo3_i2c_adapter = {
         .owner          = THIS_MODULE,
+        .id             = I2C_HW_B_VOO,
         .class          = I2C_CLASS_TV_ANALOG, 
         .name           = "I2C Voodoo3/Banshee adapter",
         .algo_data      = &voo_i2c_bit_data,
@@ -181,6 +182,7 @@ static struct i2c_algo_bit_data voo_ddc_bit_data = {
 
 static struct i2c_adapter voodoo3_ddc_adapter = {
         .owner          = THIS_MODULE,
+        .id             = I2C_HW_B_VOO,
         .class          = I2C_CLASS_DDC, 
         .name           = "DDC Voodoo3/Banshee adapter",
         .algo_data      = &voo_ddc_bit_data,
diff --git a/drivers/i2c/busses/scx200_acb.c b/drivers/i2c/busses/scx200_acb.c
index 714bae780953..0b082c5a0195 100644
--- a/drivers/i2c/busses/scx200_acb.c
+++ b/drivers/i2c/busses/scx200_acb.c
@@ -428,7 +428,7 @@ static __init int scx200_acb_probe(struct scx200_acb_iface *iface)
 }
 
 static __init struct scx200_acb_iface *scx200_create_iface(const char *text,
-                int index)
+                struct device *dev, int index)
 {
         struct scx200_acb_iface *iface;
         struct i2c_adapter *adapter;
@@ -446,6 +446,7 @@ static __init struct scx200_acb_iface *scx200_create_iface(const char *text,
         adapter->id = I2C_HW_SMBUS_SCX200;
         adapter->algo = &scx200_acb_algorithm;
         adapter->class = I2C_CLASS_HWMON;
+        adapter->dev.parent = dev;
 
         mutex_init(&iface->mutex);
 
@@ -486,7 +487,7 @@ static __init int scx200_create_pci(const char *text, struct pci_dev *pdev,
         struct scx200_acb_iface *iface;
         int rc;
 
-        iface = scx200_create_iface(text, 0);
+        iface = scx200_create_iface(text, &pdev->dev, 0);
 
         if (iface == NULL)
                 return -ENOMEM;
@@ -524,7 +525,7 @@ static int __init scx200_create_isa(const char *text, unsigned long base,
         struct scx200_acb_iface *iface;
         int rc;
 
-        iface = scx200_create_iface(text, index);
+        iface = scx200_create_iface(text, NULL, index);
 
         if (iface == NULL)
                 return -ENOMEM;
diff --git a/drivers/i2c/busses/scx200_i2c.c b/drivers/i2c/busses/scx200_i2c.c
index 6cd96e43aa72..c3022a023449 100644
--- a/drivers/i2c/busses/scx200_i2c.c
+++ b/drivers/i2c/busses/scx200_i2c.c
@@ -81,6 +81,7 @@ static struct i2c_algo_bit_data scx200_i2c_data = {
 
 static struct i2c_adapter scx200_i2c_ops = {
         .owner             = THIS_MODULE,
+        .id                = I2C_HW_B_SCX200,
         .algo_data         = &scx200_i2c_data,
         .name   = "NatSemi SCx200 I2C",
 };
diff --git a/drivers/i2c/chips/eeprom.c b/drivers/i2c/chips/eeprom.c
index cec3a0c3894d..bfce13c8f1ff 100644
--- a/drivers/i2c/chips/eeprom.c
+++ b/drivers/i2c/chips/eeprom.c
@@ -30,7 +30,6 @@
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/slab.h>
-#include <linux/sched.h>
 #include <linux/jiffies.h>
 #include <linux/i2c.h>
 #include <linux/mutex.h>
diff --git a/drivers/i2c/i2c-core.c b/drivers/i2c/i2c-core.c
index b05378a3d673..21fe1406c8b4 100644
--- a/drivers/i2c/i2c-core.c
+++ b/drivers/i2c/i2c-core.c
@@ -32,6 +32,7 @@
 #include <linux/seq_file.h>
 #include <linux/platform_device.h>
 #include <linux/mutex.h>
+#include <linux/completion.h>
 #include <asm/uaccess.h>
 
 
@@ -40,49 +41,72 @@ static LIST_HEAD(drivers);
 static DEFINE_MUTEX(core_lists);
 static DEFINE_IDR(i2c_adapter_idr);
 
+
+/* ------------------------------------------------------------------------- */
+
 /* match always succeeds, as we want the probe() to tell if we really accept this match */
 static int i2c_device_match(struct device *dev, struct device_driver *drv)
 {
         return 1;
 }
 
-static int i2c_bus_suspend(struct device * dev, pm_message_t state)
+static int i2c_device_probe(struct device *dev)
 {
-        int rc = 0;
+        return -ENODEV;
+}
 
-        if (dev->driver && dev->driver->suspend)
-                rc = dev->driver->suspend(dev, state);
-        return rc;
+static int i2c_device_remove(struct device *dev)
+{
+        return 0;
 }
 
-static int i2c_bus_resume(struct device * dev)
+static void i2c_device_shutdown(struct device *dev)
 {
-        int rc = 0;
-        
-        if (dev->driver && dev->driver->resume)
-                rc = dev->driver->resume(dev);
-        return rc;
+        struct i2c_driver *driver;
+
+        if (!dev->driver)
+                return;
+        driver = to_i2c_driver(dev->driver);
+        if (driver->shutdown)
+                driver->shutdown(to_i2c_client(dev));
 }
 
-static int i2c_device_probe(struct device *dev)
+static int i2c_device_suspend(struct device * dev, pm_message_t mesg)
 {
-        return -ENODEV;
+        struct i2c_driver *driver;
+
+        if (!dev->driver)
+                return 0;
+        driver = to_i2c_driver(dev->driver);
+        if (!driver->suspend)
+                return 0;
+        return driver->suspend(to_i2c_client(dev), mesg);
 }
 
-static int i2c_device_remove(struct device *dev)
+static int i2c_device_resume(struct device * dev)
 {
-        return 0;
+        struct i2c_driver *driver;
+
+        if (!dev->driver)
+                return 0;
+        driver = to_i2c_driver(dev->driver);
+        if (!driver->resume)
+                return 0;
+        return driver->resume(to_i2c_client(dev));
 }
 
 struct bus_type i2c_bus_type = {
-        .name =         "i2c",
-        .match =        i2c_device_match,
-        .probe =        i2c_device_probe,
-        .remove =       i2c_device_remove,
-        .suspend =      i2c_bus_suspend,
-        .resume =       i2c_bus_resume,
+        .name           = "i2c",
+        .match          = i2c_device_match,
+        .probe          = i2c_device_probe,
+        .remove         = i2c_device_remove,
+        .shutdown       = i2c_device_shutdown,
+        .suspend        = i2c_device_suspend,
+        .resume         = i2c_device_resume,
 };
 
+/* ------------------------------------------------------------------------- */
+
 void i2c_adapter_dev_release(struct device *dev)
 {
         struct i2c_adapter *adap = dev_to_i2c_adapter(dev);
@@ -193,9 +217,8 @@ int i2c_add_adapter(struct i2c_adapter *adap)
          */
         if (adap->dev.parent == NULL) {
                 adap->dev.parent = &platform_bus;
-                printk(KERN_WARNING "**WARNING** I2C adapter driver [%s] "
-                       "forgot to specify physical device; fix it!\n",
-                       adap->name);
+                pr_debug("I2C adapter driver [%s] forgot to specify "
+                         "physical device\n", adap->name);
         }
         sprintf(adap->dev.bus_id, "i2c-%d", adap->nr);
         adap->dev.driver = &i2c_adapter_driver;