Merge branch 'i2c-for-linus' of git://jdelvare.pck.nerim.net/jdelvare-2.6

* 'i2c-for-linus' of git://jdelvare.pck.nerim.net/jdelvare-2.6:
  i2c-core: Some style cleanups
  i2c-piix4: Add support for the Broadcom HT1100 chipset
  i2c-piix4: Add support to SB800 SMBus changes
  i2c-pca-platform: Use defaults if no platform_data given
  i2c-algo-pca: Use timeout for checking the state machine
  i2c-algo-pca: Rework waiting for a free bus
  i2c-algo-pca: Add PCA9665 support
  i2c: Adapt debug macros for KERN_* constants
  i2c-davinci: Fix timeout handling
  i2c: Adapter timeout is in jiffies
  i2c: Set a default timeout value for all adapters
  i2c: Add missing KERN_* constants to printks
  i2c-algo-pcf: Handle timeout correctly
  i2c-algo-pcf: Style cleanups
  eeprom/at24: Remove EXPERIMENTAL
  i2c-nforce2: Add support for MCP67, MCP73, MCP78S and MCP79
  i2c: Clarify which clients are auto-removed
  i2c: Let checkpatch shout on users of the legacy model
  i2c: Document the different ways to instantiate i2c devices

12 files changed, 163 insertions, 61 deletions

diff --git a/drivers/i2c/busses/Kconfig b/drivers/i2c/busses/Kconfig
index 7f95905bbb9d..da809ad0996a 100644
--- a/drivers/i2c/busses/Kconfig
+++ b/drivers/i2c/busses/Kconfig
@@ -132,6 +132,7 @@ config I2C_PIIX4
             Serverworks CSB5
             Serverworks CSB6
             Serverworks HT-1000
+            Serverworks HT-1100
             SMSC Victory66
 
           This driver can also be built as a module.  If so, the module
@@ -617,12 +618,12 @@ config I2C_ELEKTOR
           will be called i2c-elektor.
 
 config I2C_PCA_ISA
-        tristate "PCA9564 on an ISA bus"
+        tristate "PCA9564/PCA9665 on an ISA bus"
         depends on ISA
         select I2C_ALGOPCA
         default n
         help
-          This driver supports ISA boards using the Philips PCA9564
+          This driver supports ISA boards using the Philips PCA9564/PCA9665
           parallel bus to I2C bus controller.
 
           This driver can also be built as a module.  If so, the module
@@ -634,11 +635,11 @@ config I2C_PCA_ISA
           time).  If unsure, say N.
 
 config I2C_PCA_PLATFORM
-        tristate "PCA9564 as platform device"
+        tristate "PCA9564/PCA9665 as platform device"
         select I2C_ALGOPCA
         default n
         help
-          This driver supports a memory mapped Philips PCA9564
+          This driver supports a memory mapped Philips PCA9564/PCA9665
           parallel bus to I2C bus controller.
 
           This driver can also be built as a module.  If so, the module
diff --git a/drivers/i2c/busses/i2c-davinci.c b/drivers/i2c/busses/i2c-davinci.c
index 5d7789834b95..3fae3a91ce5b 100644
--- a/drivers/i2c/busses/i2c-davinci.c
+++ b/drivers/i2c/busses/i2c-davinci.c
@@ -216,7 +216,7 @@ static int i2c_davinci_wait_bus_not_busy(struct davinci_i2c_dev *dev,
 {
         unsigned long timeout;
 
-        timeout = jiffies + DAVINCI_I2C_TIMEOUT;
+        timeout = jiffies + dev->adapter.timeout;
         while (davinci_i2c_read_reg(dev, DAVINCI_I2C_STR_REG)
                & DAVINCI_I2C_STR_BB) {
                 if (time_after(jiffies, timeout)) {
@@ -289,7 +289,7 @@ i2c_davinci_xfer_msg(struct i2c_adapter *adap, struct i2c_msg *msg, int stop)
         davinci_i2c_write_reg(dev, DAVINCI_I2C_MDR_REG, flag);
 
         r = wait_for_completion_interruptible_timeout(&dev->cmd_complete,
-                                                      DAVINCI_I2C_TIMEOUT);
+                                                      dev->adapter.timeout);
         if (r == 0) {
                 dev_err(dev->dev, "controller timed out\n");
                 i2c_davinci_init(dev);
@@ -546,9 +546,7 @@ static int davinci_i2c_probe(struct platform_device *pdev)
         strlcpy(adap->name, "DaVinci I2C adapter", sizeof(adap->name));
         adap->algo = &i2c_davinci_algo;
         adap->dev.parent = &pdev->dev;
-
-        /* FIXME */
-        adap->timeout = 1;
+        adap->timeout = DAVINCI_I2C_TIMEOUT;
 
         adap->nr = pdev->id;
         r = i2c_add_numbered_adapter(adap);
diff --git a/drivers/i2c/busses/i2c-ibm_iic.c b/drivers/i2c/busses/i2c-ibm_iic.c
index 88f0db73b364..8b92a4666e02 100644
--- a/drivers/i2c/busses/i2c-ibm_iic.c
+++ b/drivers/i2c/busses/i2c-ibm_iic.c
@@ -415,7 +415,7 @@ static int iic_wait_for_tc(struct ibm_iic_private* dev){
         if (dev->irq >= 0){
                 /* Interrupt mode */
                 ret = wait_event_interruptible_timeout(dev->wq,
-                        !(in_8(&iic->sts) & STS_PT), dev->adap.timeout * HZ);
+                        !(in_8(&iic->sts) & STS_PT), dev->adap.timeout);
 
                 if (unlikely(ret < 0))
                         DBG("%d: wait interrupted\n", dev->idx);
@@ -426,7 +426,7 @@ static int iic_wait_for_tc(struct ibm_iic_private* dev){
         }
         else {
                 /* Polling mode */
-                unsigned long x = jiffies + dev->adap.timeout * HZ;
+                unsigned long x = jiffies + dev->adap.timeout;
 
                 while (in_8(&iic->sts) & STS_PT){
                         if (unlikely(time_after(jiffies, x))){
@@ -748,7 +748,7 @@ static int __devinit iic_probe(struct of_device *ofdev,
         i2c_set_adapdata(adap, dev);
         adap->class = I2C_CLASS_HWMON | I2C_CLASS_SPD;
         adap->algo = &iic_algo;
-        adap->timeout = 1;
+        adap->timeout = HZ;
 
         ret = i2c_add_adapter(adap);
         if (ret  < 0) {
diff --git a/drivers/i2c/busses/i2c-iop3xx.c b/drivers/i2c/busses/i2c-iop3xx.c
index 3190690c26ce..a75c75e77b92 100644
--- a/drivers/i2c/busses/i2c-iop3xx.c
+++ b/drivers/i2c/busses/i2c-iop3xx.c
@@ -488,7 +488,7 @@ iop3xx_i2c_probe(struct platform_device *pdev)
         /*
          * Default values...should these come in from board code?
          */
-        new_adapter->timeout = 100;     
+        new_adapter->timeout = HZ;
         new_adapter->algo = &iop3xx_i2c_algo;
 
         init_waitqueue_head(&adapter_data->waitq);
diff --git a/drivers/i2c/busses/i2c-mpc.c b/drivers/i2c/busses/i2c-mpc.c
index aedbbe6618db..2b847d875946 100644
--- a/drivers/i2c/busses/i2c-mpc.c
+++ b/drivers/i2c/busses/i2c-mpc.c
@@ -116,7 +116,7 @@ static int i2c_wait(struct mpc_i2c *i2c, unsigned timeout, int writing)
         } else {
                 /* Interrupt mode */
                 result = wait_event_interruptible_timeout(i2c->queue,
-                        (i2c->interrupt & CSR_MIF), timeout * HZ);
+                        (i2c->interrupt & CSR_MIF), timeout);
 
                 if (unlikely(result < 0)) {
                         pr_debug("I2C: wait interrupted\n");
@@ -311,7 +311,7 @@ static struct i2c_adapter mpc_ops = {
         .owner = THIS_MODULE,
         .name = "MPC adapter",
         .algo = &mpc_algo,
-        .timeout = 1,
+        .timeout = HZ,
 };
 
 static int __devinit fsl_i2c_probe(struct of_device *op, const struct of_device_id *match)
diff --git a/drivers/i2c/busses/i2c-mv64xxx.c b/drivers/i2c/busses/i2c-mv64xxx.c
index 7f186bbcb99d..5a4945d1dba4 100644
--- a/drivers/i2c/busses/i2c-mv64xxx.c
+++ b/drivers/i2c/busses/i2c-mv64xxx.c
@@ -358,7 +358,7 @@ mv64xxx_i2c_wait_for_completion(struct mv64xxx_i2c_data *drv_data)
         char            abort = 0;
 
         time_left = wait_event_interruptible_timeout(drv_data->waitq,
-                !drv_data->block, msecs_to_jiffies(drv_data->adapter.timeout));
+                !drv_data->block, drv_data->adapter.timeout);
 
         spin_lock_irqsave(&drv_data->lock, flags);
         if (!time_left) { /* Timed out */
@@ -374,8 +374,7 @@ mv64xxx_i2c_wait_for_completion(struct mv64xxx_i2c_data *drv_data)
                 spin_unlock_irqrestore(&drv_data->lock, flags);
 
                 time_left = wait_event_timeout(drv_data->waitq,
-                        !drv_data->block,
-                        msecs_to_jiffies(drv_data->adapter.timeout));
+                        !drv_data->block, drv_data->adapter.timeout);
 
                 if ((time_left <= 0) && drv_data->block) {
                         drv_data->state = MV64XXX_I2C_STATE_IDLE;
@@ -530,7 +529,7 @@ mv64xxx_i2c_probe(struct platform_device *pd)
         drv_data->adapter.algo = &mv64xxx_i2c_algo;
         drv_data->adapter.owner = THIS_MODULE;
         drv_data->adapter.class = I2C_CLASS_HWMON | I2C_CLASS_SPD;
-        drv_data->adapter.timeout = pdata->timeout;
+        drv_data->adapter.timeout = msecs_to_jiffies(pdata->timeout);
         drv_data->adapter.nr = pd->id;
         platform_set_drvdata(pd, drv_data);
         i2c_set_adapdata(&drv_data->adapter, drv_data);
diff --git a/drivers/i2c/busses/i2c-nforce2.c b/drivers/i2c/busses/i2c-nforce2.c
index 05af6cd7f270..2ff4683703a8 100644
--- a/drivers/i2c/busses/i2c-nforce2.c
+++ b/drivers/i2c/busses/i2c-nforce2.c
@@ -31,10 +31,14 @@
     nForce3 250Gb MCP           00E4
     nForce4 MCP                 0052
     nForce4 MCP-04              0034
-    nForce4 MCP51               0264
-    nForce4 MCP55               0368
+    nForce MCP51                0264
+    nForce MCP55                0368
     nForce MCP61                03EB
     nForce MCP65                0446
+    nForce MCP67                0542
+    nForce MCP73                07D8
+    nForce MCP78S               0752
+    nForce MCP79                0AA2
 
     This driver supports the 2 SMBuses that are included in the MCP of the
     nForce2/3/4/5xx chipsets.
@@ -315,6 +319,10 @@ static struct pci_device_id nforce2_ids[] = {
         { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_SMBUS) },
         { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_SMBUS) },
         { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP65_SMBUS) },
+        { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP67_SMBUS) },
+        { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP73_SMBUS) },
+        { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP78S_SMBUS) },
+        { PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP79_SMBUS) },
         { 0 }
 };
 
diff --git a/drivers/i2c/busses/i2c-pca-isa.c b/drivers/i2c/busses/i2c-pca-isa.c
index 4aa8138cb0a9..0ed68e2ccd22 100644
--- a/drivers/i2c/busses/i2c-pca-isa.c
+++ b/drivers/i2c/busses/i2c-pca-isa.c
@@ -23,6 +23,7 @@
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/delay.h>
+#include <linux/jiffies.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/wait.h>
@@ -41,15 +42,17 @@ static int irq = -1;
 
 /* Data sheet recommends 59kHz for 100kHz operation due to variation
  * in the actual clock rate */
-static int clock  = I2C_PCA_CON_59kHz;
+static int clock  = 59000;
 
+static struct i2c_adapter pca_isa_ops;
 static wait_queue_head_t pca_wait;
 
 static void pca_isa_writebyte(void *pd, int reg, int val)
 {
 #ifdef DEBUG_IO
         static char *names[] = { "T/O", "DAT", "ADR", "CON" };
-        printk("*** write %s at %#lx <= %#04x\n", names[reg], base+reg, val);
+        printk(KERN_DEBUG "*** write %s at %#lx <= %#04x\n", names[reg],
+               base+reg, val);
 #endif
         outb(val, base+reg);
 }
@@ -60,7 +63,7 @@ static int pca_isa_readbyte(void *pd, int reg)
 #ifdef DEBUG_IO
         {
                 static char *names[] = { "STA", "DAT", "ADR", "CON" };
-                printk("*** read  %s => %#04x\n", names[reg], res);
+                printk(KERN_DEBUG "*** read  %s => %#04x\n", names[reg], res);
         }
 #endif
         return res;
@@ -68,16 +71,22 @@ static int pca_isa_readbyte(void *pd, int reg)
 
 static int pca_isa_waitforcompletion(void *pd)
 {
-        int ret = 0;
+        long ret = ~0;
+        unsigned long timeout;
 
         if (irq > -1) {
-                ret = wait_event_interruptible(pca_wait,
-                                               pca_isa_readbyte(pd, I2C_PCA_CON) & I2C_PCA_CON_SI);
+                ret = wait_event_interruptible_timeout(pca_wait,
+                                pca_isa_readbyte(pd, I2C_PCA_CON)
+                                & I2C_PCA_CON_SI, pca_isa_ops.timeout);
         } else {
-                while ((pca_isa_readbyte(pd, I2C_PCA_CON) & I2C_PCA_CON_SI) == 0)
+                /* Do polling */
+                timeout = jiffies + pca_isa_ops.timeout;
+                while (((pca_isa_readbyte(pd, I2C_PCA_CON)
+                                & I2C_PCA_CON_SI) == 0)
+                                && (ret = time_before(jiffies, timeout)))
                         udelay(100);
         }
-        return ret;
+        return ret > 0;
 }
 
 static void pca_isa_resetchip(void *pd)
@@ -102,8 +111,8 @@ static struct i2c_algo_pca_data pca_isa_data = {
 static struct i2c_adapter pca_isa_ops = {
         .owner          = THIS_MODULE,
         .algo_data      = &pca_isa_data,
-        .name           = "PCA9564 ISA Adapter",
-        .timeout        = 100,
+        .name           = "PCA9564/PCA9665 ISA Adapter",
+        .timeout        = HZ,
 };
 
 static int __devinit pca_isa_match(struct device *dev, unsigned int id)
@@ -195,7 +204,7 @@ static void __exit pca_isa_exit(void)
 }
 
 MODULE_AUTHOR("Ian Campbell <icampbell@arcom.com>");
-MODULE_DESCRIPTION("ISA base PCA9564 driver");
+MODULE_DESCRIPTION("ISA base PCA9564/PCA9665 driver");
 MODULE_LICENSE("GPL");
 
 module_param(base, ulong, 0);
@@ -204,7 +213,13 @@ MODULE_PARM_DESC(base, "I/O base address");
 module_param(irq, int, 0);
 MODULE_PARM_DESC(irq, "IRQ");
 module_param(clock, int, 0);
-MODULE_PARM_DESC(clock, "Clock rate as described in table 1 of PCA9564 datasheet");
+MODULE_PARM_DESC(clock, "Clock rate in hertz.\n\t\t"
+                "For PCA9564: 330000,288000,217000,146000,"
+                "88000,59000,44000,36000\n"
+                "\t\tFor PCA9665:\tStandard: 60300 - 100099\n"
+                "\t\t\t\tFast: 100100 - 400099\n"
+                "\t\t\t\tFast+: 400100 - 10000099\n"
+                "\t\t\t\tTurbo: Up to 1265800");
 
 module_init(pca_isa_init);
 module_exit(pca_isa_exit);
diff --git a/drivers/i2c/busses/i2c-pca-platform.c b/drivers/i2c/busses/i2c-pca-platform.c
index 6bb15ad0a6b6..7b23891b7d59 100644
--- a/drivers/i2c/busses/i2c-pca-platform.c
+++ b/drivers/i2c/busses/i2c-pca-platform.c
@@ -15,6 +15,7 @@
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/delay.h>
+#include <linux/jiffies.h>
 #include <linux/errno.h>
 #include <linux/i2c.h>
 #include <linux/interrupt.h>
@@ -81,24 +82,23 @@ static void i2c_pca_pf_writebyte32(void *pd, int reg, int val)
 static int i2c_pca_pf_waitforcompletion(void *pd)
 {
         struct i2c_pca_pf_data *i2c = pd;
-        int ret = 0;
+        long ret = ~0;
+        unsigned long timeout;
 
         if (i2c->irq) {
-                ret = wait_event_interruptible(i2c->wait,
+                ret = wait_event_interruptible_timeout(i2c->wait,
                         i2c->algo_data.read_byte(i2c, I2C_PCA_CON)
-                        & I2C_PCA_CON_SI);
+                        & I2C_PCA_CON_SI, i2c->adap.timeout);
         } else {
-                /*
-                 * Do polling...
-                 * XXX: Could get stuck in extreme cases!
-                 *      Maybe add timeout, but using irqs is preferred anyhow.
-                 */
-                while ((i2c->algo_data.read_byte(i2c, I2C_PCA_CON)
+                /* Do polling */
+                timeout = jiffies + i2c->adap.timeout;
+                while (((i2c->algo_data.read_byte(i2c, I2C_PCA_CON)
                                 & I2C_PCA_CON_SI) == 0)
+                                && (ret = time_before(jiffies, timeout)))
                         udelay(100);
         }
 
-        return ret;
+        return ret > 0;
 }
 
 static void i2c_pca_pf_dummyreset(void *pd)
@@ -172,14 +172,25 @@ static int __devinit i2c_pca_pf_probe(struct platform_device *pdev)
 
         i2c->adap.nr = pdev->id >= 0 ? pdev->id : 0;
         i2c->adap.owner = THIS_MODULE;
-        snprintf(i2c->adap.name, sizeof(i2c->adap.name), "PCA9564 at 0x%08lx",
-                (unsigned long) res->start);
+        snprintf(i2c->adap.name, sizeof(i2c->adap.name),
+                 "PCA9564/PCA9665 at 0x%08lx",
+                 (unsigned long) res->start);
         i2c->adap.algo_data = &i2c->algo_data;
         i2c->adap.dev.parent = &pdev->dev;
-        i2c->adap.timeout = platform_data->timeout;
 
-        i2c->algo_data.i2c_clock = platform_data->i2c_clock_speed;
+        if (platform_data) {
+                i2c->adap.timeout = platform_data->timeout;
+                i2c->algo_data.i2c_clock = platform_data->i2c_clock_speed;
+                i2c->gpio = platform_data->gpio;
+        } else {
+                i2c->adap.timeout = HZ;
+                i2c->algo_data.i2c_clock = 59000;
+                i2c->gpio = -1;
+        }
+
         i2c->algo_data.data = i2c;
+        i2c->algo_data.wait_for_completion = i2c_pca_pf_waitforcompletion;
+        i2c->algo_data.reset_chip = i2c_pca_pf_dummyreset;
 
         switch (res->flags & IORESOURCE_MEM_TYPE_MASK) {
         case IORESOURCE_MEM_32BIT:
@@ -197,11 +208,6 @@ static int __devinit i2c_pca_pf_probe(struct platform_device *pdev)
                 break;
         }
 
-        i2c->algo_data.wait_for_completion = i2c_pca_pf_waitforcompletion;
-
-        i2c->gpio = platform_data->gpio;
-        i2c->algo_data.reset_chip = i2c_pca_pf_dummyreset;
-
         /* Use gpio_is_valid() when in mainline */
         if (i2c->gpio > -1) {
                 ret = gpio_request(i2c->gpio, i2c->adap.name);
@@ -246,7 +252,7 @@ e_remap:
 e_alloc:
         release_mem_region(res->start, res_len(res));
 e_print:
-        printk(KERN_ERR "Registering PCA9564 FAILED! (%d)\n", ret);
+        printk(KERN_ERR "Registering PCA9564/PCA9665 FAILED! (%d)\n", ret);
         return ret;
 }
 
@@ -290,7 +296,7 @@ static void __exit i2c_pca_pf_exit(void)
 }
 
 MODULE_AUTHOR("Wolfram Sang <w.sang@pengutronix.de>");
-MODULE_DESCRIPTION("I2C-PCA9564 platform driver");
+MODULE_DESCRIPTION("I2C-PCA9564/PCA9665 platform driver");
 MODULE_LICENSE("GPL");
 
 module_init(i2c_pca_pf_init);
diff --git a/drivers/i2c/busses/i2c-piix4.c b/drivers/i2c/busses/i2c-piix4.c
index 761f9dd53620..0249a7d762b9 100644
--- a/drivers/i2c/busses/i2c-piix4.c
+++ b/drivers/i2c/busses/i2c-piix4.c
@@ -20,7 +20,7 @@
 /*
    Supports:
         Intel PIIX4, 440MX
-        Serverworks OSB4, CSB5, CSB6, HT-1000
+        Serverworks OSB4, CSB5, CSB6, HT-1000, HT-1100
         ATI IXP200, IXP300, IXP400, SB600, SB700, SB800
         SMSC Victory66
 
@@ -226,6 +226,70 @@ static int __devinit piix4_setup(struct pci_dev *PIIX4_dev,
         return 0;
 }
 
+static int __devinit piix4_setup_sb800(struct pci_dev *PIIX4_dev,
+                                const struct pci_device_id *id)
+{
+        unsigned short smba_idx = 0xcd6;
+        u8 smba_en_lo, smba_en_hi, i2ccfg, i2ccfg_offset = 0x10, smb_en = 0x2c;
+
+        /* SB800 SMBus does not support forcing address */
+        if (force || force_addr) {
+                dev_err(&PIIX4_dev->dev, "SB800 SMBus does not support "
+                        "forcing address!\n");
+                return -EINVAL;
+        }
+
+        /* Determine the address of the SMBus areas */
+        if (!request_region(smba_idx, 2, "smba_idx")) {
+                dev_err(&PIIX4_dev->dev, "SMBus base address index region "
+                        "0x%x already in use!\n", smba_idx);
+                return -EBUSY;
+        }
+        outb_p(smb_en, smba_idx);
+        smba_en_lo = inb_p(smba_idx + 1);
+        outb_p(smb_en + 1, smba_idx);
+        smba_en_hi = inb_p(smba_idx + 1);
+        release_region(smba_idx, 2);
+
+        if ((smba_en_lo & 1) == 0) {
+                dev_err(&PIIX4_dev->dev,
+                        "Host SMBus controller not enabled!\n");
+                return -ENODEV;
+        }
+
+        piix4_smba = ((smba_en_hi << 8) | smba_en_lo) & 0xffe0;
+        if (acpi_check_region(piix4_smba, SMBIOSIZE, piix4_driver.name))
+                return -EBUSY;
+
+        if (!request_region(piix4_smba, SMBIOSIZE, piix4_driver.name)) {
+                dev_err(&PIIX4_dev->dev, "SMBus region 0x%x already in use!\n",
+                        piix4_smba);
+                return -EBUSY;
+        }
+
+        /* Request the SMBus I2C bus config region */
+        if (!request_region(piix4_smba + i2ccfg_offset, 1, "i2ccfg")) {
+                dev_err(&PIIX4_dev->dev, "SMBus I2C bus config region "
+                        "0x%x already in use!\n", piix4_smba + i2ccfg_offset);
+                release_region(piix4_smba, SMBIOSIZE);
+                piix4_smba = 0;
+                return -EBUSY;
+        }
+        i2ccfg = inb_p(piix4_smba + i2ccfg_offset);
+        release_region(piix4_smba + i2ccfg_offset, 1);
+
+        if (i2ccfg & 1)
+                dev_dbg(&PIIX4_dev->dev, "Using IRQ for SMBus.\n");
+        else
+                dev_dbg(&PIIX4_dev->dev, "Using SMI# for SMBus.\n");
+
+        dev_info(&PIIX4_dev->dev,
+                 "SMBus Host Controller at 0x%x, revision %d\n",
+                 piix4_smba, i2ccfg >> 4);
+
+        return 0;
+}
+
 static int piix4_transaction(void)
 {
         int temp;
@@ -423,6 +487,8 @@ static struct pci_device_id piix4_ids[] = {
                      PCI_DEVICE_ID_SERVERWORKS_CSB6) },
         { PCI_DEVICE(PCI_VENDOR_ID_SERVERWORKS,
                      PCI_DEVICE_ID_SERVERWORKS_HT1000SB) },
+        { PCI_DEVICE(PCI_VENDOR_ID_SERVERWORKS,
+                     PCI_DEVICE_ID_SERVERWORKS_HT1100LD) },
         { 0, }
 };
 
@@ -433,7 +499,14 @@ static int __devinit piix4_probe(struct pci_dev *dev,
 {
         int retval;
 
-        retval = piix4_setup(dev, id);
+        if ((dev->vendor == PCI_VENDOR_ID_ATI) &&
+            (dev->device == PCI_DEVICE_ID_ATI_SBX00_SMBUS) &&
+            (dev->revision >= 0x40))
+                /* base address location etc changed in SB800 */
+                retval = piix4_setup_sb800(dev, id);
+        else
+                retval = piix4_setup(dev, id);
+
         if (retval)
                 return retval;
 
diff --git a/drivers/i2c/busses/i2c-powermac.c b/drivers/i2c/busses/i2c-powermac.c
index 60ca91745e55..3c9d71f60187 100644
--- a/drivers/i2c/busses/i2c-powermac.c
+++ b/drivers/i2c/busses/i2c-powermac.c
@@ -191,7 +191,8 @@ static int __devexit i2c_powermac_remove(struct platform_device *dev)
         i2c_set_adapdata(adapter, NULL);
         /* We aren't that prepared to deal with this... */
         if (rc)
-                printk("i2c-powermac.c: Failed to remove bus %s !\n",
+                printk(KERN_WARNING
+                       "i2c-powermac.c: Failed to remove bus %s !\n",
                        adapter->name);
         platform_set_drvdata(dev, NULL);
         kfree(adapter);
diff --git a/drivers/i2c/busses/i2c-pxa.c b/drivers/i2c/busses/i2c-pxa.c
index bdb1f7510e91..c1405c8f6ba5 100644
--- a/drivers/i2c/busses/i2c-pxa.c
+++ b/drivers/i2c/busses/i2c-pxa.c
@@ -210,11 +210,12 @@ static irqreturn_t i2c_pxa_handler(int this_irq, void *dev_id);
 static void i2c_pxa_scream_blue_murder(struct pxa_i2c *i2c, const char *why)
 {
         unsigned int i;
-        printk("i2c: error: %s\n", why);
-        printk("i2c: msg_num: %d msg_idx: %d msg_ptr: %d\n",
+        printk(KERN_ERR "i2c: error: %s\n", why);
+        printk(KERN_ERR "i2c: msg_num: %d msg_idx: %d msg_ptr: %d\n",
                 i2c->msg_num, i2c->msg_idx, i2c->msg_ptr);
-        printk("i2c: ICR: %08x ISR: %08x\n"
-               "i2c: log: ", readl(_ICR(i2c)), readl(_ISR(i2c)));
+        printk(KERN_ERR "i2c: ICR: %08x ISR: %08x\n",
+               readl(_ICR(i2c)), readl(_ISR(i2c)));
+        printk(KERN_DEBUG "i2c: log: ");
         for (i = 0; i < i2c->irqlogidx; i++)
                 printk("[%08x:%08x] ", i2c->isrlog[i], i2c->icrlog[i]);
         printk("\n");