Merge branch 'origin' into for-linus

Conflicts:
	MAINTAINERS

18 files changed, 661 insertions, 735 deletions

diff --git a/drivers/i2c/Kconfig b/drivers/i2c/Kconfig
index 711ca08ab776..d7ece131b4f4 100644
--- a/drivers/i2c/Kconfig
+++ b/drivers/i2c/Kconfig
@@ -27,6 +27,14 @@ config I2C_BOARDINFO
         boolean
         default y
 
+config I2C_COMPAT
+        boolean "Enable compatibility bits for old user-space"
+        default y
+        help
+          Say Y here if you intend to run lm-sensors 3.1.1 or older, or any
+          other user-space package which expects i2c adapters to be class
+          devices. If you don't know, say Y.
+
 config I2C_CHARDEV
         tristate "I2C device interface"
         help
diff --git a/drivers/i2c/busses/Kconfig b/drivers/i2c/busses/Kconfig
index 834a03414900..737335ff2b21 100644
--- a/drivers/i2c/busses/Kconfig
+++ b/drivers/i2c/busses/Kconfig
@@ -113,7 +113,7 @@ config I2C_ISCH
           will be called i2c-isch.
 
 config I2C_PIIX4
-        tristate "Intel PIIX4 and compatible (ATI/Serverworks/Broadcom/SMSC)"
+        tristate "Intel PIIX4 and compatible (ATI/AMD/Serverworks/Broadcom/SMSC)"
         depends on PCI
         help
           If you say yes to this option, support will be included for the Intel
@@ -128,6 +128,7 @@ config I2C_PIIX4
             ATI SB600
             ATI SB700
             ATI SB800
+            AMD SB900
             Serverworks OSB4
             Serverworks CSB5
             Serverworks CSB6
@@ -231,6 +232,22 @@ config I2C_VIAPRO
           This driver can also be built as a module.  If so, the module
           will be called i2c-viapro.
 
+if ACPI
+
+comment "ACPI drivers"
+
+config I2C_SCMI
+        tristate "SMBus Control Method Interface"
+        help
+          This driver supports the SMBus Control Method Interface. It needs the
+          BIOS to declare ACPI control methods as described in the SMBus Control
+          Method Interface specification.
+
+          To compile this driver as a module, choose M here:
+          the module will be called i2c-scmi.
+
+endif # ACPI
+
 comment "Mac SMBus host controller drivers"
         depends on PPC_CHRP || PPC_PMAC
 
diff --git a/drivers/i2c/busses/Makefile b/drivers/i2c/busses/Makefile
index e654263bfc01..ff937ac69f5b 100644
--- a/drivers/i2c/busses/Makefile
+++ b/drivers/i2c/busses/Makefile
@@ -2,6 +2,9 @@
 # Makefile for the i2c bus drivers.
 #
 
+# ACPI drivers
+obj-$(CONFIG_I2C_SCMI)          += i2c-scmi.o
+
 # PC SMBus host controller drivers
 obj-$(CONFIG_I2C_ALI1535)       += i2c-ali1535.o
 obj-$(CONFIG_I2C_ALI1563)       += i2c-ali1563.o
diff --git a/drivers/i2c/busses/i2c-imx.c b/drivers/i2c/busses/i2c-imx.c
index 0b486a63460d..4afba3ec2a61 100644
--- a/drivers/i2c/busses/i2c-imx.c
+++ b/drivers/i2c/busses/i2c-imx.c
@@ -609,13 +609,12 @@ static int __init i2c_adap_imx_init(void)
 {
         return platform_driver_probe(&i2c_imx_driver, i2c_imx_probe);
 }
+subsys_initcall(i2c_adap_imx_init);
 
 static void __exit i2c_adap_imx_exit(void)
 {
         platform_driver_unregister(&i2c_imx_driver);
 }
-
-module_init(i2c_adap_imx_init);
 module_exit(i2c_adap_imx_exit);
 
 MODULE_LICENSE("GPL");
diff --git a/drivers/i2c/busses/i2c-mv64xxx.c b/drivers/i2c/busses/i2c-mv64xxx.c
index c3869d94ad42..bbab0e166630 100644
--- a/drivers/i2c/busses/i2c-mv64xxx.c
+++ b/drivers/i2c/busses/i2c-mv64xxx.c
@@ -293,13 +293,13 @@ mv64xxx_i2c_do_action(struct mv64xxx_i2c_data *drv_data)
         }
 }
 
-static int
+static irqreturn_t
 mv64xxx_i2c_intr(int irq, void *dev_id)
 {
         struct mv64xxx_i2c_data *drv_data = dev_id;
         unsigned long   flags;
         u32             status;
-        int             rc = IRQ_NONE;
+        irqreturn_t     rc = IRQ_NONE;
 
         spin_lock_irqsave(&drv_data->lock, flags);
         while (readl(drv_data->reg_base + MV64XXX_I2C_REG_CONTROL) &
diff --git a/drivers/i2c/busses/i2c-piix4.c b/drivers/i2c/busses/i2c-piix4.c
index 0249a7d762b9..a782c7a08f9e 100644
--- a/drivers/i2c/busses/i2c-piix4.c
+++ b/drivers/i2c/busses/i2c-piix4.c
@@ -22,6 +22,7 @@
         Intel PIIX4, 440MX
         Serverworks OSB4, CSB5, CSB6, HT-1000, HT-1100
         ATI IXP200, IXP300, IXP400, SB600, SB700, SB800
+        AMD SB900
         SMSC Victory66
 
    Note: we assume there can only be one device, with one SMBus interface.
@@ -479,6 +480,7 @@ static struct pci_device_id piix4_ids[] = {
         { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_IXP300_SMBUS) },
         { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_IXP400_SMBUS) },
         { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_SBX00_SMBUS) },
+        { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_SB900_SMBUS) },
         { PCI_DEVICE(PCI_VENDOR_ID_SERVERWORKS,
                      PCI_DEVICE_ID_SERVERWORKS_OSB4) },
         { PCI_DEVICE(PCI_VENDOR_ID_SERVERWORKS,
@@ -499,9 +501,10 @@ static int __devinit piix4_probe(struct pci_dev *dev,
 {
         int retval;
 
-        if ((dev->vendor == PCI_VENDOR_ID_ATI) &&
-            (dev->device == PCI_DEVICE_ID_ATI_SBX00_SMBUS) &&
-            (dev->revision >= 0x40))
+        if ((dev->vendor == PCI_VENDOR_ID_ATI &&
+             dev->device == PCI_DEVICE_ID_ATI_SBX00_SMBUS &&
+             dev->revision >= 0x40) ||
+            dev->vendor == PCI_VENDOR_ID_AMD)
                 /* base address location etc changed in SB800 */
                 retval = piix4_setup_sb800(dev, id);
         else
diff --git a/drivers/i2c/busses/i2c-pnx.c b/drivers/i2c/busses/i2c-pnx.c
index ec15cff556b9..6ff6c20f1e78 100644
--- a/drivers/i2c/busses/i2c-pnx.c
+++ b/drivers/i2c/busses/i2c-pnx.c
@@ -586,7 +586,8 @@ static int __devinit i2c_pnx_probe(struct platform_device *pdev)
         alg_data->mif.timer.data = (unsigned long)i2c_pnx->adapter;
 
         /* Register I/O resource */
-        if (!request_region(alg_data->base, I2C_PNX_REGION_SIZE, pdev->name)) {
+        if (!request_mem_region(alg_data->base, I2C_PNX_REGION_SIZE,
+                                pdev->name)) {
                 dev_err(&pdev->dev,
                        "I/O region 0x%08x for I2C already in use.\n",
                        alg_data->base);
@@ -650,7 +651,7 @@ out_clock:
 out_unmap:
         iounmap((void *)alg_data->ioaddr);
 out_release:
-        release_region(alg_data->base, I2C_PNX_REGION_SIZE);
+        release_mem_region(alg_data->base, I2C_PNX_REGION_SIZE);
 out_drvdata:
         platform_set_drvdata(pdev, NULL);
 out:
@@ -667,7 +668,7 @@ static int __devexit i2c_pnx_remove(struct platform_device *pdev)
         i2c_del_adapter(adap);
         i2c_pnx->set_clock_stop(pdev);
         iounmap((void *)alg_data->ioaddr);
-        release_region(alg_data->base, I2C_PNX_REGION_SIZE);
+        release_mem_region(alg_data->base, I2C_PNX_REGION_SIZE);
         platform_set_drvdata(pdev, NULL);
 
         return 0;
diff --git a/drivers/i2c/busses/i2c-scmi.c b/drivers/i2c/busses/i2c-scmi.c
new file mode 100644
index 000000000000..276a046ac93f
--- /dev/null
+++ b/drivers/i2c/busses/i2c-scmi.c
@@ -0,0 +1,430 @@
+/*
+ * SMBus driver for ACPI SMBus CMI
+ *
+ * Copyright (C) 2009 Crane Cai <crane.cai@amd.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 version 2.
+ */
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/kernel.h>
+#include <linux/stddef.h>
+#include <linux/init.h>
+#include <linux/i2c.h>
+#include <linux/acpi.h>
+
+#define ACPI_SMBUS_HC_CLASS             "smbus"
+#define ACPI_SMBUS_HC_DEVICE_NAME       "cmi"
+
+ACPI_MODULE_NAME("smbus_cmi");
+
+struct smbus_methods_t {
+        char *mt_info;
+        char *mt_sbr;
+        char *mt_sbw;
+};
+
+struct acpi_smbus_cmi {
+        acpi_handle handle;
+        struct i2c_adapter adapter;
+        u8 cap_info:1;
+        u8 cap_read:1;
+        u8 cap_write:1;
+};
+
+static const struct smbus_methods_t smbus_methods = {
+        .mt_info = "_SBI",
+        .mt_sbr  = "_SBR",
+        .mt_sbw  = "_SBW",
+};
+
+static const struct acpi_device_id acpi_smbus_cmi_ids[] = {
+        {"SMBUS01", 0},
+        {"", 0}
+};
+
+#define ACPI_SMBUS_STATUS_OK                    0x00
+#define ACPI_SMBUS_STATUS_FAIL                  0x07
+#define ACPI_SMBUS_STATUS_DNAK                  0x10
+#define ACPI_SMBUS_STATUS_DERR                  0x11
+#define ACPI_SMBUS_STATUS_CMD_DENY              0x12
+#define ACPI_SMBUS_STATUS_UNKNOWN               0x13
+#define ACPI_SMBUS_STATUS_ACC_DENY              0x17
+#define ACPI_SMBUS_STATUS_TIMEOUT               0x18
+#define ACPI_SMBUS_STATUS_NOTSUP                0x19
+#define ACPI_SMBUS_STATUS_BUSY                  0x1a
+#define ACPI_SMBUS_STATUS_PEC                   0x1f
+
+#define ACPI_SMBUS_PRTCL_WRITE                  0x00
+#define ACPI_SMBUS_PRTCL_READ                   0x01
+#define ACPI_SMBUS_PRTCL_QUICK                  0x02
+#define ACPI_SMBUS_PRTCL_BYTE                   0x04
+#define ACPI_SMBUS_PRTCL_BYTE_DATA              0x06
+#define ACPI_SMBUS_PRTCL_WORD_DATA              0x08
+#define ACPI_SMBUS_PRTCL_BLOCK_DATA             0x0a
+
+
+static int
+acpi_smbus_cmi_access(struct i2c_adapter *adap, u16 addr, unsigned short flags,
+                   char read_write, u8 command, int size,
+                   union i2c_smbus_data *data)
+{
+        int result = 0;
+        struct acpi_smbus_cmi *smbus_cmi = adap->algo_data;
+        unsigned char protocol;
+        acpi_status status = 0;
+        struct acpi_object_list input;
+        union acpi_object mt_params[5];
+        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
+        union acpi_object *obj;
+        union acpi_object *pkg;
+        char *method;
+        int len = 0;
+
+        dev_dbg(&adap->dev, "access size: %d %s\n", size,
+                (read_write) ? "READ" : "WRITE");
+        switch (size) {
+        case I2C_SMBUS_QUICK:
+                protocol = ACPI_SMBUS_PRTCL_QUICK;
+                command = 0;
+                if (read_write == I2C_SMBUS_WRITE) {
+                        mt_params[3].type = ACPI_TYPE_INTEGER;
+                        mt_params[3].integer.value = 0;
+                        mt_params[4].type = ACPI_TYPE_INTEGER;
+                        mt_params[4].integer.value = 0;
+                }
+                break;
+
+        case I2C_SMBUS_BYTE:
+                protocol = ACPI_SMBUS_PRTCL_BYTE;
+                if (read_write == I2C_SMBUS_WRITE) {
+                        mt_params[3].type = ACPI_TYPE_INTEGER;
+                        mt_params[3].integer.value = 0;
+                        mt_params[4].type = ACPI_TYPE_INTEGER;
+                        mt_params[4].integer.value = 0;
+                } else {
+                        command = 0;
+                }
+                break;
+
+        case I2C_SMBUS_BYTE_DATA:
+                protocol = ACPI_SMBUS_PRTCL_BYTE_DATA;
+                if (read_write == I2C_SMBUS_WRITE) {
+                        mt_params[3].type = ACPI_TYPE_INTEGER;
+                        mt_params[3].integer.value = 1;
+                        mt_params[4].type = ACPI_TYPE_INTEGER;
+                        mt_params[4].integer.value = data->byte;
+                }
+                break;
+
+        case I2C_SMBUS_WORD_DATA:
+                protocol = ACPI_SMBUS_PRTCL_WORD_DATA;
+                if (read_write == I2C_SMBUS_WRITE) {
+                        mt_params[3].type = ACPI_TYPE_INTEGER;
+                        mt_params[3].integer.value = 2;
+                        mt_params[4].type = ACPI_TYPE_INTEGER;
+                        mt_params[4].integer.value = data->word;
+                }
+                break;
+
+        case I2C_SMBUS_BLOCK_DATA:
+                protocol = ACPI_SMBUS_PRTCL_BLOCK_DATA;
+                if (read_write == I2C_SMBUS_WRITE) {
+                        len = data->block[0];
+                        if (len == 0 || len > I2C_SMBUS_BLOCK_MAX)
+                                return -EINVAL;
+                        mt_params[3].type = ACPI_TYPE_INTEGER;
+                        mt_params[3].integer.value = len;
+                        mt_params[4].type = ACPI_TYPE_BUFFER;
+                        mt_params[4].buffer.pointer = data->block + 1;
+                }
+                break;
+
+        default:
+                dev_warn(&adap->dev, "Unsupported transaction %d\n", size);
+                return -EOPNOTSUPP;
+        }
+
+        if (read_write == I2C_SMBUS_READ) {
+                protocol |= ACPI_SMBUS_PRTCL_READ;
+                method = smbus_methods.mt_sbr;
+                input.count = 3;
+        } else {
+                protocol |= ACPI_SMBUS_PRTCL_WRITE;
+                method = smbus_methods.mt_sbw;
+                input.count = 5;
+        }
+
+        input.pointer = mt_params;
+        mt_params[0].type = ACPI_TYPE_INTEGER;
+        mt_params[0].integer.value = protocol;
+        mt_params[1].type = ACPI_TYPE_INTEGER;
+        mt_params[1].integer.value = addr;
+        mt_params[2].type = ACPI_TYPE_INTEGER;
+        mt_params[2].integer.value = command;
+
+        status = acpi_evaluate_object(smbus_cmi->handle, method, &input,
+                                      &buffer);
+        if (ACPI_FAILURE(status)) {
+                ACPI_ERROR((AE_INFO, "Evaluating %s: %i", method, status));
+                return -EIO;
+        }
+
+        pkg = buffer.pointer;
+        if (pkg && pkg->type == ACPI_TYPE_PACKAGE)
+                obj = pkg->package.elements;
+        else {
+                ACPI_ERROR((AE_INFO, "Invalid argument type"));
+                result = -EIO;
+                goto out;
+        }
+        if (obj == NULL || obj->type != ACPI_TYPE_INTEGER) {
+                ACPI_ERROR((AE_INFO, "Invalid argument type"));
+                result = -EIO;
+                goto out;
+        }
+
+        result = obj->integer.value;
+        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "%s return status: %i\n",
+                          method, result));
+
+        switch (result) {
+        case ACPI_SMBUS_STATUS_OK:
+                result = 0;
+                break;
+        case ACPI_SMBUS_STATUS_BUSY:
+                result = -EBUSY;
+                goto out;
+        case ACPI_SMBUS_STATUS_TIMEOUT:
+                result = -ETIMEDOUT;
+                goto out;
+        case ACPI_SMBUS_STATUS_DNAK:
+                result = -ENXIO;
+                goto out;
+        default:
+                result = -EIO;
+                goto out;
+        }
+
+        if (read_write == I2C_SMBUS_WRITE || size == I2C_SMBUS_QUICK)
+                goto out;
+
+        obj = pkg->package.elements + 1;
+        if (obj == NULL || obj->type != ACPI_TYPE_INTEGER) {
+                ACPI_ERROR((AE_INFO, "Invalid argument type"));
+                result = -EIO;
+                goto out;
+        }
+
+        len = obj->integer.value;
+        obj = pkg->package.elements + 2;
+        switch (size) {
+        case I2C_SMBUS_BYTE:
+        case I2C_SMBUS_BYTE_DATA:
+        case I2C_SMBUS_WORD_DATA:
+                if (obj == NULL || obj->type != ACPI_TYPE_INTEGER) {
+                        ACPI_ERROR((AE_INFO, "Invalid argument type"));
+                        result = -EIO;
+                        goto out;
+                }
+                if (len == 2)
+                        data->word = obj->integer.value;
+                else
+                        data->byte = obj->integer.value;
+                break;
+        case I2C_SMBUS_BLOCK_DATA:
+                if (obj == NULL || obj->type != ACPI_TYPE_BUFFER) {
+                        ACPI_ERROR((AE_INFO, "Invalid argument type"));
+                        result = -EIO;
+                        goto out;
+                }
+                if (len == 0 || len > I2C_SMBUS_BLOCK_MAX)
+                        return -EPROTO;
+                data->block[0] = len;
+                memcpy(data->block + 1, obj->buffer.pointer, len);
+                break;
+        }
+
+out:
+        kfree(buffer.pointer);
+        dev_dbg(&adap->dev, "Transaction status: %i\n", result);
+        return result;
+}
+
+static u32 acpi_smbus_cmi_func(struct i2c_adapter *adapter)
+{
+        struct acpi_smbus_cmi *smbus_cmi = adapter->algo_data;
+        u32 ret;
+
+        ret = smbus_cmi->cap_read | smbus_cmi->cap_write ?
+                I2C_FUNC_SMBUS_QUICK : 0;
+
+        ret |= smbus_cmi->cap_read ?
+                (I2C_FUNC_SMBUS_READ_BYTE |
+                I2C_FUNC_SMBUS_READ_BYTE_DATA |
+                I2C_FUNC_SMBUS_READ_WORD_DATA |
+                I2C_FUNC_SMBUS_READ_BLOCK_DATA) : 0;
+
+        ret |= smbus_cmi->cap_write ?
+                (I2C_FUNC_SMBUS_WRITE_BYTE |
+                I2C_FUNC_SMBUS_WRITE_BYTE_DATA |
+                I2C_FUNC_SMBUS_WRITE_WORD_DATA |
+                I2C_FUNC_SMBUS_WRITE_BLOCK_DATA) : 0;
+
+        return ret;
+}
+
+static const struct i2c_algorithm acpi_smbus_cmi_algorithm = {
+        .smbus_xfer = acpi_smbus_cmi_access,
+        .functionality = acpi_smbus_cmi_func,
+};
+
+
+static int acpi_smbus_cmi_add_cap(struct acpi_smbus_cmi *smbus_cmi,
+                                  const char *name)
+{
+        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
+        union acpi_object *obj;
+        acpi_status status;
+
+        if (!strcmp(name, smbus_methods.mt_info)) {
+                status = acpi_evaluate_object(smbus_cmi->handle,
+                                        smbus_methods.mt_info,
+                                        NULL, &buffer);
+                if (ACPI_FAILURE(status)) {
+                        ACPI_ERROR((AE_INFO, "Evaluating %s: %i",
+                                   smbus_methods.mt_info, status));
+                        return -EIO;
+                }
+
+                obj = buffer.pointer;
+                if (obj && obj->type == ACPI_TYPE_PACKAGE)
+                        obj = obj->package.elements;
+                else {
+                        ACPI_ERROR((AE_INFO, "Invalid argument type"));
+                        kfree(buffer.pointer);
+                        return -EIO;
+                }
+
+                if (obj->type != ACPI_TYPE_INTEGER) {
+                        ACPI_ERROR((AE_INFO, "Invalid argument type"));
+                        kfree(buffer.pointer);
+                        return -EIO;
+                } else
+                        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "SMBus CMI Version %x"
+                                          "\n", (int)obj->integer.value));
+
+                kfree(buffer.pointer);
+                smbus_cmi->cap_info = 1;
+        } else if (!strcmp(name, smbus_methods.mt_sbr))
+                smbus_cmi->cap_read = 1;
+        else if (!strcmp(name, smbus_methods.mt_sbw))
+                smbus_cmi->cap_write = 1;
+        else
+                ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Unsupported CMI method: %s\n",
+                                 name));
+
+        return 0;
+}
+
+static acpi_status acpi_smbus_cmi_query_methods(acpi_handle handle, u32 level,
+                        void *context, void **return_value)
+{
+        char node_name[5];
+        struct acpi_buffer buffer = { sizeof(node_name), node_name };
+        struct acpi_smbus_cmi *smbus_cmi = context;
+        acpi_status status;
+
+        status = acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer);
+
+        if (ACPI_SUCCESS(status))
+                acpi_smbus_cmi_add_cap(smbus_cmi, node_name);
+
+        return AE_OK;
+}
+
+static int acpi_smbus_cmi_add(struct acpi_device *device)
+{
+        struct acpi_smbus_cmi *smbus_cmi;
+
+        smbus_cmi = kzalloc(sizeof(struct acpi_smbus_cmi), GFP_KERNEL);
+        if (!smbus_cmi)
+                return -ENOMEM;
+
+        smbus_cmi->handle = device->handle;
+        strcpy(acpi_device_name(device), ACPI_SMBUS_HC_DEVICE_NAME);
+        strcpy(acpi_device_class(device), ACPI_SMBUS_HC_CLASS);
+        device->driver_data = smbus_cmi;
+        smbus_cmi->cap_info = 0;
+        smbus_cmi->cap_read = 0;
+        smbus_cmi->cap_write = 0;
+
+        acpi_walk_namespace(ACPI_TYPE_METHOD, smbus_cmi->handle, 1,
+                            acpi_smbus_cmi_query_methods, smbus_cmi, NULL);
+
+        if (smbus_cmi->cap_info == 0)
+                goto err;
+
+        snprintf(smbus_cmi->adapter.name, sizeof(smbus_cmi->adapter.name),
+                "SMBus CMI adapter %s (%s)",
+                acpi_device_name(device),
+                acpi_device_uid(device));
+        smbus_cmi->adapter.owner = THIS_MODULE;
+        smbus_cmi->adapter.algo = &acpi_smbus_cmi_algorithm;
+        smbus_cmi->adapter.algo_data = smbus_cmi;
+        smbus_cmi->adapter.class = I2C_CLASS_HWMON | I2C_CLASS_SPD;
+        smbus_cmi->adapter.dev.parent = &device->dev;
+
+        if (i2c_add_adapter(&smbus_cmi->adapter)) {
+                dev_err(&device->dev, "Couldn't register adapter!\n");
+                goto err;
+        }
+
+        return 0;
+
+err:
+        kfree(smbus_cmi);
+        device->driver_data = NULL;
+        return -EIO;
+}
+
+static int acpi_smbus_cmi_remove(struct acpi_device *device, int type)
+{
+        struct acpi_smbus_cmi *smbus_cmi = acpi_driver_data(device);
+
+        i2c_del_adapter(&smbus_cmi->adapter);
+        kfree(smbus_cmi);
+        device->driver_data = NULL;
+
+        return 0;
+}
+
+static struct acpi_driver acpi_smbus_cmi_driver = {
+        .name = ACPI_SMBUS_HC_DEVICE_NAME,
+        .class = ACPI_SMBUS_HC_CLASS,
+        .ids = acpi_smbus_cmi_ids,
+        .ops = {
+                .add = acpi_smbus_cmi_add,
+                .remove = acpi_smbus_cmi_remove,
+        },
+};
+
+static int __init acpi_smbus_cmi_init(void)
+{
+        return acpi_bus_register_driver(&acpi_smbus_cmi_driver);
+}
+
+static void __exit acpi_smbus_cmi_exit(void)
+{
+        acpi_bus_unregister_driver(&acpi_smbus_cmi_driver);
+}
+
+module_init(acpi_smbus_cmi_init);
+module_exit(acpi_smbus_cmi_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Crane Cai <crane.cai@amd.com>");
+MODULE_DESCRIPTION("ACPI SMBus CMI driver");
diff --git a/drivers/i2c/busses/i2c-sh_mobile.c b/drivers/i2c/busses/i2c-sh_mobile.c
index 820487d0d5c7..86a9d4e81472 100644
--- a/drivers/i2c/busses/i2c-sh_mobile.c
+++ b/drivers/i2c/busses/i2c-sh_mobile.c
@@ -28,6 +28,7 @@
 #include <linux/interrupt.h>
 #include <linux/i2c.h>
 #include <linux/err.h>
+#include <linux/pm_runtime.h>
 #include <linux/clk.h>
 #include <linux/io.h>
 
@@ -165,7 +166,8 @@ static void activate_ch(struct sh_mobile_i2c_data *pd)
         u_int32_t denom;
         u_int32_t tmp;
 
-        /* Make sure the clock is enabled */
+        /* Wake up device and enable clock */
+        pm_runtime_get_sync(pd->dev);
         clk_enable(pd->clk);
 
         /* Get clock rate after clock is enabled */
@@ -213,8 +215,9 @@ static void deactivate_ch(struct sh_mobile_i2c_data *pd)
         /* Disable channel */
         iowrite8(ioread8(ICCR(pd)) & ~ICCR_ICE, ICCR(pd));
 
-        /* Disable clock */
+        /* Disable clock and mark device as idle */
         clk_disable(pd->clk);
+        pm_runtime_put_sync(pd->dev);
 }
 
 static unsigned char i2c_op(struct sh_mobile_i2c_data *pd,
@@ -572,6 +575,19 @@ static int sh_mobile_i2c_probe(struct platform_device *dev)
                 goto err_irq;
         }
 
+        /* Enable Runtime PM for this device.
+         *
+         * Also tell the Runtime PM core to ignore children
+         * for this device since it is valid for us to suspend
+         * this I2C master driver even though the slave devices
+         * on the I2C bus may not be suspended.
+         *
+         * The state of the I2C hardware bus is unaffected by
+         * the Runtime PM state.
+         */
+        pm_suspend_ignore_children(&dev->dev, true);
+        pm_runtime_enable(&dev->dev);
+
         /* setup the private data */
         adap = &pd->adap;
         i2c_set_adapdata(adap, pd);
@@ -614,14 +630,33 @@ static int sh_mobile_i2c_remove(struct platform_device *dev)
         iounmap(pd->reg);
         sh_mobile_i2c_hook_irqs(dev, 0);
         clk_put(pd->clk);
+        pm_runtime_disable(&dev->dev);
         kfree(pd);
         return 0;
 }
 
+static int sh_mobile_i2c_runtime_nop(struct device *dev)
+{
+        /* Runtime PM callback shared between ->runtime_suspend()
+         * and ->runtime_resume(). Simply returns success.
+         *
+         * This driver re-initializes all registers after
+         * pm_runtime_get_sync() anyway so there is no need
+         * to save and restore registers here.
+         */
+        return 0;
+}
+
+static struct dev_pm_ops sh_mobile_i2c_dev_pm_ops = {
+        .runtime_suspend = sh_mobile_i2c_runtime_nop,
+        .runtime_resume = sh_mobile_i2c_runtime_nop,
+};
+
 static struct platform_driver sh_mobile_i2c_driver = {
         .driver         = {
                 .name           = "i2c-sh_mobile",
                 .owner          = THIS_MODULE,
+                .pm             = &sh_mobile_i2c_dev_pm_ops,
         },
         .probe          = sh_mobile_i2c_probe,
         .remove         = sh_mobile_i2c_remove,
diff --git a/drivers/i2c/busses/i2c-taos-evm.c b/drivers/i2c/busses/i2c-taos-evm.c
index 224aa12ee7c8..dd39c1eb03ed 100644
--- a/drivers/i2c/busses/i2c-taos-evm.c
+++ b/drivers/i2c/busses/i2c-taos-evm.c
@@ -32,10 +32,12 @@
 
 #define TAOS_STATE_INIT         0
 #define TAOS_STATE_IDLE         1
-#define TAOS_STATE_SEND         2
+#define TAOS_STATE_EOFF         2
 #define TAOS_STATE_RECV         3
 
 #define TAOS_CMD_RESET          0x12
+#define TAOS_CMD_ECHO_ON        '+'
+#define TAOS_CMD_ECHO_OFF       '-'
 
 static DECLARE_WAIT_QUEUE_HEAD(wq);
 
@@ -102,17 +104,9 @@ static int taos_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
 
         /* Send the transaction to the TAOS EVM */
         dev_dbg(&adapter->dev, "Command buffer: %s\n", taos->buffer);
-        taos->pos = 0;
-        taos->state = TAOS_STATE_SEND;
-        serio_write(serio, taos->buffer[0]);
-        wait_event_interruptible_timeout(wq, taos->state == TAOS_STATE_IDLE,
-                                         msecs_to_jiffies(250));
-        if (taos->state != TAOS_STATE_IDLE) {
-                dev_err(&adapter->dev, "Transaction failed "
-                        "(state=%d, pos=%d)\n", taos->state, taos->pos);
-                taos->addr = 0;
-                return -EIO;
-        }
+        for (p = taos->buffer; *p; p++)
+                serio_write(serio, *p);
+
         taos->addr = addr;
 
         /* Start the transaction and read the answer */
@@ -122,7 +116,7 @@ static int taos_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
         wait_event_interruptible_timeout(wq, taos->state == TAOS_STATE_IDLE,
                                          msecs_to_jiffies(150));
         if (taos->state != TAOS_STATE_IDLE
-         || taos->pos != 6) {
+         || taos->pos != 5) {
                 dev_err(&adapter->dev, "Transaction timeout (pos=%d)\n",
                         taos->pos);
                 return -EIO;
@@ -130,7 +124,7 @@ static int taos_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
         dev_dbg(&adapter->dev, "Answer buffer: %s\n", taos->buffer);
 
         /* Interpret the returned string */
-        p = taos->buffer + 2;
+        p = taos->buffer + 1;
         p[3] = '\0';
         if (!strcmp(p, "NAK"))
                 return -ENODEV;
@@ -173,13 +167,9 @@ static irqreturn_t taos_interrupt(struct serio *serio, unsigned char data,
                         wake_up_interruptible(&wq);
                 }
                 break;
-        case TAOS_STATE_SEND:
-                if (taos->buffer[++taos->pos])
-                        serio_write(serio, taos->buffer[taos->pos]);
-                else {
-                        taos->state = TAOS_STATE_IDLE;
-                        wake_up_interruptible(&wq);
-                }
+        case TAOS_STATE_EOFF:
+                taos->state = TAOS_STATE_IDLE;
+                wake_up_interruptible(&wq);
                 break;
         case TAOS_STATE_RECV:
                 taos->buffer[taos->pos++] = data;
@@ -257,6 +247,19 @@ static int taos_connect(struct serio *serio, struct serio_driver *drv)
         }
         strlcpy(adapter->name, name, sizeof(adapter->name));
 
+        /* Turn echo off for better performance */
+        taos->state = TAOS_STATE_EOFF;
+        serio_write(serio, TAOS_CMD_ECHO_OFF);
+
+        wait_event_interruptible_timeout(wq, taos->state == TAOS_STATE_IDLE,
+                                         msecs_to_jiffies(250));
+        if (taos->state != TAOS_STATE_IDLE) {
+                err = -ENODEV;
+                dev_err(&adapter->dev, "Echo off failed "
+                        "(state=%d)\n", taos->state);
+                goto exit_close;
+        }
+
         err = i2c_add_adapter(adapter);
         if (err)
                 goto exit_close;
diff --git a/drivers/i2c/busses/scx200_acb.c b/drivers/i2c/busses/scx200_acb.c
index 648ecc6f60e6..cf994bd01d9c 100644
--- a/drivers/i2c/busses/scx200_acb.c
+++ b/drivers/i2c/busses/scx200_acb.c
@@ -217,8 +217,10 @@ static void scx200_acb_machine(struct scx200_acb_iface *iface, u8 status)
         return;
 
  error:
-        dev_err(&iface->adapter.dev, "%s in state %s\n", errmsg,
-                scx200_acb_state_name[iface->state]);
+        dev_err(&iface->adapter.dev,
+                "%s in state %s (addr=0x%02x, len=%d, status=0x%02x)\n", errmsg,
+                scx200_acb_state_name[iface->state], iface->address_byte,
+                iface->len, status);
 
         iface->state = state_idle;
         iface->result = -EIO;
diff --git a/drivers/i2c/chips/Kconfig b/drivers/i2c/chips/Kconfig
index 02d746c9c474..f9618f4d4e47 100644
--- a/drivers/i2c/chips/Kconfig
+++ b/drivers/i2c/chips/Kconfig
@@ -16,54 +16,6 @@ config DS1682
           This driver can also be built as a module.  If so, the module
           will be called ds1682.
 
-config SENSORS_PCF8574
-        tristate "Philips PCF8574 and PCF8574A (DEPRECATED)"
-        depends on EXPERIMENTAL && GPIO_PCF857X = "n"
-        default n
-        help
-          If you say yes here you get support for Philips PCF8574 and 
-          PCF8574A chips. These chips are 8-bit I/O expanders for the I2C bus.
-
-          This driver can also be built as a module.  If so, the module
-          will be called pcf8574.
-
-          This driver is deprecated and will be dropped soon. Use
-          drivers/gpio/pcf857x.c instead.
-
-          These devices are hard to detect and rarely found on mainstream
-          hardware.  If unsure, say N.
-
-config PCF8575
-        tristate "Philips PCF8575 (DEPRECATED)"
-        default n
-        depends on GPIO_PCF857X = "n"
-        help
-          If you say yes here you get support for Philips PCF8575 chip.
-          This chip is a 16-bit I/O expander for the I2C bus.  Several other
-          chip manufacturers sell equivalent chips, e.g. Texas Instruments.
-
-          This driver can also be built as a module.  If so, the module
-          will be called pcf8575.
-
-          This driver is deprecated and will be dropped soon. Use
-          drivers/gpio/pcf857x.c instead.
-
-          This device is hard to detect and is rarely found on mainstream
-          hardware.  If unsure, say N.
-
-config SENSORS_PCA9539
-        tristate "Philips PCA9539 16-bit I/O port (DEPRECATED)"
-        depends on EXPERIMENTAL && GPIO_PCA953X = "n"
-        help
-          If you say yes here you get support for the Philips PCA9539
-          16-bit I/O port.
-
-          This driver can also be built as a module.  If so, the module
-          will be called pca9539.
-
-          This driver is deprecated and will be dropped soon. Use
-          drivers/gpio/pca953x.c instead.
-
 config SENSORS_TSL2550
         tristate "Taos TSL2550 ambient light sensor"
         depends on EXPERIMENTAL
diff --git a/drivers/i2c/chips/Makefile b/drivers/i2c/chips/Makefile
index f4680d16ee34..749cf3606294 100644
--- a/drivers/i2c/chips/Makefile
+++ b/drivers/i2c/chips/Makefile
@@ -11,9 +11,6 @@
 #
 
 obj-$(CONFIG_DS1682)            += ds1682.o
-obj-$(CONFIG_SENSORS_PCA9539)   += pca9539.o
-obj-$(CONFIG_SENSORS_PCF8574)   += pcf8574.o
-obj-$(CONFIG_PCF8575)           += pcf8575.o
 obj-$(CONFIG_SENSORS_TSL2550)   += tsl2550.o
 
 ifeq ($(CONFIG_I2C_DEBUG_CHIP),y)
diff --git a/drivers/i2c/chips/pca9539.c b/drivers/i2c/chips/pca9539.c
deleted file mode 100644
index 270de4e56a81..000000000000
--- a/drivers/i2c/chips/pca9539.c
+++ /dev/null
@@ -1,152 +0,0 @@
-/*
-    pca9539.c - 16-bit I/O port with interrupt and reset
-
-    Copyright (C) 2005 Ben Gardner <bgardner@wabtec.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; version 2 of the License.
-*/
-
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/slab.h>
-#include <linux/i2c.h>
-#include <linux/hwmon-sysfs.h>
-
-/* Addresses to scan: none, device is not autodetected */
-static const unsigned short normal_i2c[] = { I2C_CLIENT_END };
-
-/* Insmod parameters */
-I2C_CLIENT_INSMOD_1(pca9539);
-
-enum pca9539_cmd
-{
-        PCA9539_INPUT_0         = 0,
-        PCA9539_INPUT_1         = 1,
-        PCA9539_OUTPUT_0        = 2,
-        PCA9539_OUTPUT_1        = 3,
-        PCA9539_INVERT_0        = 4,
-        PCA9539_INVERT_1        = 5,
-        PCA9539_DIRECTION_0     = 6,
-        PCA9539_DIRECTION_1     = 7,
-};
-
-/* following are the sysfs callback functions */
-static ssize_t pca9539_show(struct device *dev, struct device_attribute *attr,
-                            char *buf)
-{
-        struct sensor_device_attribute *psa = to_sensor_dev_attr(attr);
-        struct i2c_client *client = to_i2c_client(dev);
-        return sprintf(buf, "%d\n", i2c_smbus_read_byte_data(client,
-                                                             psa->index));
-}
-
-static ssize_t pca9539_store(struct device *dev, struct device_attribute *attr,
-                             const char *buf, size_t count)
-{
-        struct sensor_device_attribute *psa = to_sensor_dev_attr(attr);
-        struct i2c_client *client = to_i2c_client(dev);
-        unsigned long val = simple_strtoul(buf, NULL, 0);
-        if (val > 0xff)
-                return -EINVAL;
-        i2c_smbus_write_byte_data(client, psa->index, val);
-        return count;
-}
-
-/* Define the device attributes */
-
-#define PCA9539_ENTRY_RO(name, cmd_idx) \
-        static SENSOR_DEVICE_ATTR(name, S_IRUGO, pca9539_show, NULL, cmd_idx)
-
-#define PCA9539_ENTRY_RW(name, cmd_idx) \
-        static SENSOR_DEVICE_ATTR(name, S_IRUGO | S_IWUSR, pca9539_show, \
-                                  pca9539_store, cmd_idx)
-
-PCA9539_ENTRY_RO(input0, PCA9539_INPUT_0);
-PCA9539_ENTRY_RO(input1, PCA9539_INPUT_1);
-PCA9539_ENTRY_RW(output0, PCA9539_OUTPUT_0);
-PCA9539_ENTRY_RW(output1, PCA9539_OUTPUT_1);
-PCA9539_ENTRY_RW(invert0, PCA9539_INVERT_0);
-PCA9539_ENTRY_RW(invert1, PCA9539_INVERT_1);
-PCA9539_ENTRY_RW(direction0, PCA9539_DIRECTION_0);
-PCA9539_ENTRY_RW(direction1, PCA9539_DIRECTION_1);
-
-static struct attribute *pca9539_attributes[] = {
-        &sensor_dev_attr_input0.dev_attr.attr,
-        &sensor_dev_attr_input1.dev_attr.attr,
-        &sensor_dev_attr_output0.dev_attr.attr,
-        &sensor_dev_attr_output1.dev_attr.attr,
-        &sensor_dev_attr_invert0.dev_attr.attr,
-        &sensor_dev_attr_invert1.dev_attr.attr,
-        &sensor_dev_attr_direction0.dev_attr.attr,
-        &sensor_dev_attr_direction1.dev_attr.attr,
-        NULL
-};
-
-static struct attribute_group pca9539_defattr_group = {
-        .attrs = pca9539_attributes,
-};
-
-/* Return 0 if detection is successful, -ENODEV otherwise */
-static int pca9539_detect(struct i2c_client *client, int kind,
-                          struct i2c_board_info *info)
-{
-        struct i2c_adapter *adapter = client->adapter;
-
-        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
-                return -ENODEV;
-
-        strlcpy(info->type, "pca9539", I2C_NAME_SIZE);
-
-        return 0;
-}
-
-static int pca9539_probe(struct i2c_client *client,
-                         const struct i2c_device_id *id)
-{
-        /* Register sysfs hooks */
-        return sysfs_create_group(&client->dev.kobj,
-                                  &pca9539_defattr_group);
-}
-
-static int pca9539_remove(struct i2c_client *client)
-{
-        sysfs_remove_group(&client->dev.kobj, &pca9539_defattr_group);
-        return 0;
-}
-
-static const struct i2c_device_id pca9539_id[] = {
-        { "pca9539", 0 },
-        { }
-};
-
-static struct i2c_driver pca9539_driver = {
-        .driver = {
-                .name   = "pca9539",
-        },
-        .probe          = pca9539_probe,
-        .remove         = pca9539_remove,
-        .id_table       = pca9539_id,
-
-        .detect         = pca9539_detect,
-        .address_data   = &addr_data,
-};
-
-static int __init pca9539_init(void)
-{
-        return i2c_add_driver(&pca9539_driver);
-}
-
-static void __exit pca9539_exit(void)
-{
-        i2c_del_driver(&pca9539_driver);
-}
-
-MODULE_AUTHOR("Ben Gardner <bgardner@wabtec.com>");
-MODULE_DESCRIPTION("PCA9539 driver");
-MODULE_LICENSE("GPL");
-
-module_init(pca9539_init);
-module_exit(pca9539_exit);
-
diff --git a/drivers/i2c/chips/pcf8574.c b/drivers/i2c/chips/pcf8574.c
deleted file mode 100644
index 6ec309894c88..000000000000
--- a/drivers/i2c/chips/pcf8574.c
+++ /dev/null
@@ -1,215 +0,0 @@
-/*
-    Copyright (c) 2000  Frodo Looijaard <frodol@dds.nl>, 
-                        Philip Edelbrock <phil@netroedge.com>,
-                        Dan Eaton <dan.eaton@rocketlogix.com>
-    Ported to Linux 2.6 by Aurelien Jarno <aurel32@debian.org> with 
-    the help of 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.
-*/
-
-/* 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.
-
-  --Dan
-
-*/
-
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/slab.h>
-#include <linux/i2c.h>
-
-/* Addresses to scan: none, device can't be detected */
-static const unsigned short normal_i2c[] = { I2C_CLIENT_END };
-
-/* Insmod parameters */
-I2C_CLIENT_INSMOD_2(pcf8574, pcf8574a);
-
-/* Each client has this additional data */
-struct pcf8574_data {
-        int write;                      /* Remember last written value */
-};
-
-static void pcf8574_init_client(struct i2c_client *client);
-
-/* following are the sysfs callback functions */
-static ssize_t show_read(struct device *dev, struct device_attribute *attr, char *buf)
-{
-        struct i2c_client *client = to_i2c_client(dev);
-        return sprintf(buf, "%u\n", i2c_smbus_read_byte(client));
-}
-
-static DEVICE_ATTR(read, S_IRUGO, show_read, NULL);
-
-static ssize_t show_write(struct device *dev, struct device_attribute *attr, char *buf)
-{
-        struct pcf8574_data *data = i2c_get_clientdata(to_i2c_client(dev));
-
-        if (data->write < 0)
-                return data->write;
-
-        return sprintf(buf, "%d\n", data->write);
-}
-
-static ssize_t set_write(struct device *dev, struct device_attribute *attr, const char *buf,
-                         size_t count)
-{
-        struct i2c_client *client = to_i2c_client(dev);
-        struct pcf8574_data *data = i2c_get_clientdata(client);
-        unsigned long val = simple_strtoul(buf, NULL, 10);
-
-        if (val > 0xff)
-                return -EINVAL;
-
-        data->write = val;
-        i2c_smbus_write_byte(client, data->write);
-        return count;
-}
-
-static DEVICE_ATTR(write, S_IWUSR | S_IRUGO, show_write, set_write);
-
-static struct attribute *pcf8574_attributes[] = {
-        &dev_attr_read.attr,
-        &dev_attr_write.attr,
-        NULL
-};
-
-static const struct attribute_group pcf8574_attr_group = {
-        .attrs = pcf8574_attributes,
-};
-
-/*
- * Real code
- */
-
-/* Return 0 if detection is successful, -ENODEV otherwise */
-static int pcf8574_detect(struct i2c_client *client, int kind,
-                          struct i2c_board_info *info)
-{
-        struct i2c_adapter *adapter = client->adapter;
-        const char *client_name;
-
-        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
-                return -ENODEV;
-
-        /* 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 (client->addr >= 0x38 && client->addr <= 0x3f)
-                        kind = pcf8574a;
-                else
-                        kind = pcf8574;
-        }
-
-        if (kind == pcf8574a)
-                client_name = "pcf8574a";
-        else
-                client_name = "pcf8574";
-        strlcpy(info->type, client_name, I2C_NAME_SIZE);
-
-        return 0;
-}
-
-static int pcf8574_probe(struct i2c_client *client,
-                         const struct i2c_device_id *id)
-{
-        struct pcf8574_data *data;
-        int err;
-
-        data = kzalloc(sizeof(struct pcf8574_data), GFP_KERNEL);
-        if (!data) {
-                err = -ENOMEM;
-                goto exit;
-        }
-
-        i2c_set_clientdata(client, data);
-
-        /* Initialize the PCF8574 chip */
-        pcf8574_init_client(client);
-
-        /* Register sysfs hooks */
-        err = sysfs_create_group(&client->dev.kobj, &pcf8574_attr_group);
-        if (err)
-                goto exit_free;
-        return 0;
-
-      exit_free:
-        kfree(data);
-      exit:
-        return err;
-}
-
-static int pcf8574_remove(struct i2c_client *client)
-{
-        sysfs_remove_group(&client->dev.kobj, &pcf8574_attr_group);
-        kfree(i2c_get_clientdata(client));
-        return 0;
-}
-
-/* Called when we have found a new PCF8574. */
-static void pcf8574_init_client(struct i2c_client *client)
-{
-        struct pcf8574_data *data = i2c_get_clientdata(client);
-        data->write = -EAGAIN;
-}
-
-static const struct i2c_device_id pcf8574_id[] = {
-        { "pcf8574", 0 },
-        { "pcf8574a", 0 },
-        { }
-};
-
-static struct i2c_driver pcf8574_driver = {
-        .driver = {
-                .name   = "pcf8574",
-        },
-        .probe          = pcf8574_probe,
-        .remove         = pcf8574_remove,
-        .id_table       = pcf8574_id,
-
-        .detect         = pcf8574_detect,
-        .address_data   = &addr_data,
-};
-
-static int __init pcf8574_init(void)
-{
-        return i2c_add_driver(&pcf8574_driver);
-}
-
-static void __exit 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_LICENSE("GPL");
-
-module_init(pcf8574_init);
-module_exit(pcf8574_exit);
diff --git a/drivers/i2c/chips/pcf8575.c b/drivers/i2c/chips/pcf8575.c
deleted file mode 100644
index 07fd7cb3c57d..000000000000
--- a/drivers/i2c/chips/pcf8575.c
+++ /dev/null
@@ -1,198 +0,0 @@
-/*
-  pcf8575.c
-
-  About the PCF8575 chip: the PCF8575 is a 16-bit I/O expander for the I2C bus
-  produced by a.o. Philips Semiconductors.
-
-  Copyright (C) 2006 Michael Hennerich, Analog Devices Inc.
-  <hennerich@blackfin.uclinux.org>
-  Based on pcf8574.c.
-
-  Copyright (c) 2007 Bart Van Assche <bart.vanassche@gmail.com>.
-  Ported this driver from ucLinux to the mainstream Linux kernel.
-
-  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/init.h>
-#include <linux/i2c.h>
-#include <linux/slab.h>  /* kzalloc() */
-#include <linux/sysfs.h> /* sysfs_create_group() */
-
-/* Addresses to scan: none, device can't be detected */
-static const unsigned short normal_i2c[] = { I2C_CLIENT_END };
-
-/* Insmod parameters */
-I2C_CLIENT_INSMOD;
-
-
-/* Each client has this additional data */
-struct pcf8575_data {
-        int write;              /* last written value, or error code */
-};
-
-/* following are the sysfs callback functions */
-static ssize_t show_read(struct device *dev, struct device_attribute *attr,
-                         char *buf)
-{
-        struct i2c_client *client = to_i2c_client(dev);
-        u16 val;
-        u8 iopin_state[2];
-
-        i2c_master_recv(client, iopin_state, 2);
-
-        val = iopin_state[0];
-        val |= iopin_state[1] << 8;
-
-        return sprintf(buf, "%u\n", val);
-}
-
-static DEVICE_ATTR(read, S_IRUGO, show_read, NULL);
-
-static ssize_t show_write(struct device *dev, struct device_attribute *attr,
-                          char *buf)
-{
-        struct pcf8575_data *data = dev_get_drvdata(dev);
-        if (data->write < 0)
-                return data->write;
-        return sprintf(buf, "%d\n", data->write);
-}
-
-static ssize_t set_write(struct device *dev, struct device_attribute *attr,
-                         const char *buf, size_t count)
-{
-        struct i2c_client *client = to_i2c_client(dev);
-        struct pcf8575_data *data = i2c_get_clientdata(client);
-        unsigned long val = simple_strtoul(buf, NULL, 10);
-        u8 iopin_state[2];
-
-        if (val > 0xffff)
-                return -EINVAL;
-
-        data->write = val;
-
-        iopin_state[0] = val & 0xFF;
-        iopin_state[1] = val >> 8;
-
-        i2c_master_send(client, iopin_state, 2);
-
-        return count;
-}
-
-static DEVICE_ATTR(write, S_IWUSR | S_IRUGO, show_write, set_write);
-
-static struct attribute *pcf8575_attributes[] = {
-        &dev_attr_read.attr,
-        &dev_attr_write.attr,
-        NULL
-};
-
-static const struct attribute_group pcf8575_attr_group = {
-        .attrs = pcf8575_attributes,
-};
-
-/*
- * Real code
- */
-
-/* Return 0 if detection is successful, -ENODEV otherwise */
-static int pcf8575_detect(struct i2c_client *client, int kind,
-                          struct i2c_board_info *info)
-{
-        struct i2c_adapter *adapter = client->adapter;
-
-        if (!i2c_check_functionality(adapter, I2C_FUNC_I2C))
-                return -ENODEV;
-
-        /* This is the place to detect whether the chip at the specified
-           address really is a PCF8575 chip. However, there is no method known
-           to detect whether an I2C chip is a PCF8575 or any other I2C chip. */
-
-        strlcpy(info->type, "pcf8575", I2C_NAME_SIZE);
-
-        return 0;
-}
-
-static int pcf8575_probe(struct i2c_client *client,
-                         const struct i2c_device_id *id)
-{
-        struct pcf8575_data *data;
-        int err;
-
-        data = kzalloc(sizeof(struct pcf8575_data), GFP_KERNEL);
-        if (!data) {
-                err = -ENOMEM;
-                goto exit;
-        }
-
-        i2c_set_clientdata(client, data);
-        data->write = -EAGAIN;
-
-        /* Register sysfs hooks */
-        err = sysfs_create_group(&client->dev.kobj, &pcf8575_attr_group);
-        if (err)
-                goto exit_free;
-
-        return 0;
-
-exit_free:
-        kfree(data);
-exit:
-        return err;
-}
-
-static int pcf8575_remove(struct i2c_client *client)
-{
-        sysfs_remove_group(&client->dev.kobj, &pcf8575_attr_group);
-        kfree(i2c_get_clientdata(client));
-        return 0;
-}
-
-static const struct i2c_device_id pcf8575_id[] = {
-        { "pcf8575", 0 },
-        { }
-};
-
-static struct i2c_driver pcf8575_driver = {
-        .driver = {
-                .owner  = THIS_MODULE,
-                .name   = "pcf8575",
-        },
-        .probe          = pcf8575_probe,
-        .remove         = pcf8575_remove,
-        .id_table       = pcf8575_id,
-
-        .detect         = pcf8575_detect,
-        .address_data   = &addr_data,
-};
-
-static int __init pcf8575_init(void)
-{
-        return i2c_add_driver(&pcf8575_driver);
-}
-
-static void __exit pcf8575_exit(void)
-{
-        i2c_del_driver(&pcf8575_driver);
-}
-
-MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>, "
-              "Bart Van Assche <bart.vanassche@gmail.com>");
-MODULE_DESCRIPTION("pcf8575 driver");
-MODULE_LICENSE("GPL");
-
-module_init(pcf8575_init);
-module_exit(pcf8575_exit);
diff --git a/drivers/i2c/chips/tsl2550.c b/drivers/i2c/chips/tsl2550.c
index b96f3025e588..aa96bd2d27ea 100644
--- a/drivers/i2c/chips/tsl2550.c
+++ b/drivers/i2c/chips/tsl2550.c
@@ -24,10 +24,9 @@
 #include <linux/slab.h>
 #include <linux/i2c.h>
 #include <linux/mutex.h>
-#include <linux/delay.h>
 
 #define TSL2550_DRV_NAME        "tsl2550"
-#define DRIVER_VERSION          "1.1.2"
+#define DRIVER_VERSION          "1.2"
 
 /*
  * Defines
@@ -96,32 +95,13 @@ static int tsl2550_set_power_state(struct i2c_client *client, int state)
 
 static int tsl2550_get_adc_value(struct i2c_client *client, u8 cmd)
 {
-        unsigned long end;
-        int loop = 0, ret = 0;
+        int ret;
 
-        /*
-         * Read ADC channel waiting at most 400ms (see data sheet for further
-         * info).
-         * To avoid long busy wait we spin for few milliseconds then
-         * start sleeping.
-         */
-        end = jiffies + msecs_to_jiffies(400);
-        while (time_before(jiffies, end)) {
-                i2c_smbus_write_byte(client, cmd);
-
-                if (loop++ < 5)
-                        mdelay(1);
-                else
-                        msleep(1);
-
-                ret = i2c_smbus_read_byte(client);
-                if (ret < 0)
-                        return ret;
-                else if (ret & 0x0080)
-                        break;
-        }
+        ret = i2c_smbus_read_byte_data(client, cmd);
+        if (ret < 0)
+                return ret;
         if (!(ret & 0x80))
-                return -EIO;
+                return -EAGAIN;
         return ret & 0x7f;      /* remove the "valid" bit */
 }
 
@@ -285,8 +265,6 @@ static ssize_t __tsl2550_show_lux(struct i2c_client *client, char *buf)
                 return ret;
         ch0 = ret;
 
-        mdelay(1);
-
         ret = tsl2550_get_adc_value(client, TSL2550_READ_ADC1);
         if (ret < 0)
                 return ret;
@@ -345,11 +323,10 @@ static int tsl2550_init_client(struct i2c_client *client)
          * Probe the chip. To do so we try to power up the device and then to
          * read back the 0x03 code
          */
-        err = i2c_smbus_write_byte(client, TSL2550_POWER_UP);
+        err = i2c_smbus_read_byte_data(client, TSL2550_POWER_UP);
         if (err < 0)
                 return err;
-        mdelay(1);
-        if (i2c_smbus_read_byte(client) != TSL2550_POWER_UP)
+        if (err != TSL2550_POWER_UP)
                 return -ENODEV;
         data->power_state = 1;
 
@@ -374,7 +351,8 @@ static int __devinit tsl2550_probe(struct i2c_client *client,
         struct tsl2550_data *data;
         int *opmode, err = 0;
 
-        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE)) {
+        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WRITE_BYTE
+                                            | I2C_FUNC_SMBUS_READ_BYTE_DATA)) {
                 err = -EIO;
                 goto exit;
         }
diff --git a/drivers/i2c/i2c-core.c b/drivers/i2c/i2c-core.c
index 0e45c296d3d2..8d80fceca6a4 100644
--- a/drivers/i2c/i2c-core.c
+++ b/drivers/i2c/i2c-core.c
@@ -46,6 +46,7 @@ static DEFINE_MUTEX(core_lock);
 static DEFINE_IDR(i2c_adapter_idr);
 static LIST_HEAD(userspace_devices);
 
+static struct device_type i2c_client_type;
 static int i2c_check_addr(struct i2c_adapter *adapter, int addr);
 static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver);
 
@@ -64,9 +65,13 @@ static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
 
 static int i2c_device_match(struct device *dev, struct device_driver *drv)
 {
-        struct i2c_client       *client = to_i2c_client(dev);
-        struct i2c_driver       *driver = to_i2c_driver(drv);
+        struct i2c_client       *client = i2c_verify_client(dev);
+        struct i2c_driver       *driver;
+
+        if (!client)
+                return 0;
 
+        driver = to_i2c_driver(drv);
         /* match on an id table if there is one */
         if (driver->id_table)
                 return i2c_match_id(driver->id_table, client) != NULL;
@@ -94,10 +99,14 @@ static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
 
 static int i2c_device_probe(struct device *dev)
 {
-        struct i2c_client       *client = to_i2c_client(dev);
-        struct i2c_driver       *driver = to_i2c_driver(dev->driver);
+        struct i2c_client       *client = i2c_verify_client(dev);
+        struct i2c_driver       *driver;
         int status;
 
+        if (!client)
+                return 0;
+
+        driver = to_i2c_driver(dev->driver);
         if (!driver->probe || !driver->id_table)
                 return -ENODEV;
         client->driver = driver;
@@ -114,11 +123,11 @@ static int i2c_device_probe(struct device *dev)
 
 static int i2c_device_remove(struct device *dev)
 {
-        struct i2c_client       *client = to_i2c_client(dev);
+        struct i2c_client       *client = i2c_verify_client(dev);
         struct i2c_driver       *driver;
         int                     status;
 
-        if (!dev->driver)
+        if (!client || !dev->driver)
                 return 0;
 
         driver = to_i2c_driver(dev->driver);
@@ -136,37 +145,40 @@ static int i2c_device_remove(struct device *dev)
 
 static void i2c_device_shutdown(struct device *dev)
 {
+        struct i2c_client *client = i2c_verify_client(dev);
         struct i2c_driver *driver;
 
-        if (!dev->driver)
+        if (!client || !dev->driver)
                 return;
         driver = to_i2c_driver(dev->driver);
         if (driver->shutdown)
-                driver->shutdown(to_i2c_client(dev));
+                driver->shutdown(client);
 }
 
 static int i2c_device_suspend(struct device *dev, pm_message_t mesg)
 {
+        struct i2c_client *client = i2c_verify_client(dev);
         struct i2c_driver *driver;
 
-        if (!dev->driver)
+        if (!client || !dev->driver)
                 return 0;
         driver = to_i2c_driver(dev->driver);
         if (!driver->suspend)
                 return 0;
-        return driver->suspend(to_i2c_client(dev), mesg);
+        return driver->suspend(client, mesg);
 }
 
 static int i2c_device_resume(struct device *dev)
 {
+        struct i2c_client *client = i2c_verify_client(dev);
         struct i2c_driver *driver;
 
-        if (!dev->driver)
+        if (!client || !dev->driver)
                 return 0;
         driver = to_i2c_driver(dev->driver);
         if (!driver->resume)
                 return 0;
-        return driver->resume(to_i2c_client(dev));
+        return driver->resume(client);
 }
 
 static void i2c_client_dev_release(struct device *dev)
@@ -175,10 +187,10 @@ static void i2c_client_dev_release(struct device *dev)
 }
 
 static ssize_t
-show_client_name(struct device *dev, struct device_attribute *attr, char *buf)
+show_name(struct device *dev, struct device_attribute *attr, char *buf)
 {
-        struct i2c_client *client = to_i2c_client(dev);
-        return sprintf(buf, "%s\n", client->name);
+        return sprintf(buf, "%s\n", dev->type == &i2c_client_type ?
+                       to_i2c_client(dev)->name : to_i2c_adapter(dev)->name);
 }
 
 static ssize_t
@@ -188,18 +200,28 @@ show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
         return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
 }
 
-static struct device_attribute i2c_dev_attrs[] = {
-        __ATTR(name, S_IRUGO, show_client_name, NULL),
+static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
+static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
+
+static struct attribute *i2c_dev_attrs[] = {
+        &dev_attr_name.attr,
         /* modalias helps coldplug:  modprobe $(cat .../modalias) */
-        __ATTR(modalias, S_IRUGO, show_modalias, NULL),
-        { },
+        &dev_attr_modalias.attr,
+        NULL
+};
+
+static struct attribute_group i2c_dev_attr_group = {
+        .attrs          = i2c_dev_attrs,
+};
+
+static const struct attribute_group *i2c_dev_attr_groups[] = {
+        &i2c_dev_attr_group,
+        NULL
 };
 
 struct bus_type i2c_bus_type = {
         .name           = "i2c",
-        .dev_attrs      = i2c_dev_attrs,
         .match          = i2c_device_match,
-        .uevent         = i2c_device_uevent,
         .probe          = i2c_device_probe,
         .remove         = i2c_device_remove,
         .shutdown       = i2c_device_shutdown,
@@ -208,6 +230,12 @@ struct bus_type i2c_bus_type = {
 };
 EXPORT_SYMBOL_GPL(i2c_bus_type);
 
+static struct device_type i2c_client_type = {
+        .groups         = i2c_dev_attr_groups,
+        .uevent         = i2c_device_uevent,
+        .release        = i2c_client_dev_release,
+};
+
 
 /**
  * i2c_verify_client - return parameter as i2c_client, or NULL
@@ -220,7 +248,7 @@ EXPORT_SYMBOL_GPL(i2c_bus_type);
  */
 struct i2c_client *i2c_verify_client(struct device *dev)
 {
-        return (dev->bus == &i2c_bus_type)
+        return (dev->type == &i2c_client_type)
                         ? to_i2c_client(dev)
                         : NULL;
 }
@@ -273,7 +301,7 @@ i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
 
         client->dev.parent = &client->adapter->dev;
         client->dev.bus = &i2c_bus_type;
-        client->dev.release = i2c_client_dev_release;
+        client->dev.type = &i2c_client_type;
 
         dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
                      client->addr);
@@ -368,13 +396,6 @@ static void i2c_adapter_dev_release(struct device *dev)
         complete(&adap->dev_released);
 }
 
-static ssize_t
-show_adapter_name(struct device *dev, struct device_attribute *attr, char *buf)
-{
-        struct i2c_adapter *adap = to_i2c_adapter(dev);
-        return sprintf(buf, "%s\n", adap->name);
-}
-
 /*
  * Let users instantiate I2C devices through sysfs. This can be used when
  * platform initialization code doesn't contain the proper data for
@@ -493,19 +514,34 @@ i2c_sysfs_delete_device(struct device *dev, struct device_attribute *attr,
         return res;
 }
 
-static struct device_attribute i2c_adapter_attrs[] = {
-        __ATTR(name, S_IRUGO, show_adapter_name, NULL),
-        __ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device),
-        __ATTR(delete_device, S_IWUSR, NULL, i2c_sysfs_delete_device),
-        { },
+static DEVICE_ATTR(new_device, S_IWUSR, NULL, i2c_sysfs_new_device);
+static DEVICE_ATTR(delete_device, S_IWUSR, NULL, i2c_sysfs_delete_device);
+
+static struct attribute *i2c_adapter_attrs[] = {
+        &dev_attr_name.attr,
+        &dev_attr_new_device.attr,
+        &dev_attr_delete_device.attr,
+        NULL
 };
 
-static struct class i2c_adapter_class = {
-        .owner                  = THIS_MODULE,
-        .name                   = "i2c-adapter",
-        .dev_attrs              = i2c_adapter_attrs,
+static struct attribute_group i2c_adapter_attr_group = {
+        .attrs          = i2c_adapter_attrs,
 };
 
+static const struct attribute_group *i2c_adapter_attr_groups[] = {
+        &i2c_adapter_attr_group,
+        NULL
+};
+
+static struct device_type i2c_adapter_type = {
+        .groups         = i2c_adapter_attr_groups,
+        .release        = i2c_adapter_dev_release,
+};
+
+#ifdef CONFIG_I2C_COMPAT
+static struct class_compat *i2c_adapter_compat_class;
+#endif
+
 static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
 {
         struct i2c_devinfo      *devinfo;
@@ -555,14 +591,22 @@ static int i2c_register_adapter(struct i2c_adapter *adap)
                 adap->timeout = HZ;
 
         dev_set_name(&adap->dev, "i2c-%d", adap->nr);
-        adap->dev.release = &i2c_adapter_dev_release;
-        adap->dev.class = &i2c_adapter_class;
+        adap->dev.bus = &i2c_bus_type;
+        adap->dev.type = &i2c_adapter_type;
         res = device_register(&adap->dev);
         if (res)
                 goto out_list;
 
         dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
 
+#ifdef CONFIG_I2C_COMPAT
+        res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
+                                       adap->dev.parent);
+        if (res)
+                dev_warn(&adap->dev,
+                         "Failed to create compatibility class link\n");
+#endif
+
         /* create pre-declared device nodes */
         if (adap->nr < __i2c_first_dynamic_bus_num)
                 i2c_scan_static_board_info(adap);
@@ -741,6 +785,11 @@ int i2c_del_adapter(struct i2c_adapter *adap)
            checking the returned value. */
         res = device_for_each_child(&adap->dev, NULL, __unregister_client);
 
+#ifdef CONFIG_I2C_COMPAT
+        class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
+                                 adap->dev.parent);
+#endif
+
         /* clean up the sysfs representation */
         init_completion(&adap->dev_released);
         device_unregister(&adap->dev);
@@ -768,9 +817,13 @@ EXPORT_SYMBOL(i2c_del_adapter);
 
 static int __attach_adapter(struct device *dev, void *data)
 {
-        struct i2c_adapter *adapter = to_i2c_adapter(dev);
+        struct i2c_adapter *adapter;
         struct i2c_driver *driver = data;
 
+        if (dev->type != &i2c_adapter_type)
+                return 0;
+        adapter = to_i2c_adapter(dev);
+
         i2c_detect(adapter, driver);
 
         /* Legacy drivers scan i2c busses directly */
@@ -809,8 +862,7 @@ int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
         INIT_LIST_HEAD(&driver->clients);
         /* Walk the adapters that are already present */
         mutex_lock(&core_lock);
-        class_for_each_device(&i2c_adapter_class, NULL, driver,
-                              __attach_adapter);
+        bus_for_each_dev(&i2c_bus_type, NULL, driver, __attach_adapter);
         mutex_unlock(&core_lock);
 
         return 0;
@@ -819,10 +871,14 @@ EXPORT_SYMBOL(i2c_register_driver);
 
 static int __detach_adapter(struct device *dev, void *data)
 {
-        struct i2c_adapter *adapter = to_i2c_adapter(dev);
+        struct i2c_adapter *adapter;
         struct i2c_driver *driver = data;
         struct i2c_client *client, *_n;
 
+        if (dev->type != &i2c_adapter_type)
+                return 0;
+        adapter = to_i2c_adapter(dev);
+
         /* Remove the devices we created ourselves as the result of hardware
          * probing (using a driver's detect method) */
         list_for_each_entry_safe(client, _n, &driver->clients, detected) {
@@ -850,8 +906,7 @@ static int __detach_adapter(struct device *dev, void *data)
 void i2c_del_driver(struct i2c_driver *driver)
 {
         mutex_lock(&core_lock);
-        class_for_each_device(&i2c_adapter_class, NULL, driver,
-                              __detach_adapter);
+        bus_for_each_dev(&i2c_bus_type, NULL, driver, __detach_adapter);
         mutex_unlock(&core_lock);
 
         driver_unregister(&driver->driver);
@@ -940,17 +995,23 @@ static int __init i2c_init(void)
         retval = bus_register(&i2c_bus_type);
         if (retval)
                 return retval;
-        retval = class_register(&i2c_adapter_class);
-        if (retval)
+#ifdef CONFIG_I2C_COMPAT
+        i2c_adapter_compat_class = class_compat_register("i2c-adapter");
+        if (!i2c_adapter_compat_class) {
+                retval = -ENOMEM;
                 goto bus_err;
+        }
+#endif
         retval = i2c_add_driver(&dummy_driver);
         if (retval)
                 goto class_err;
         return 0;
 
 class_err:
-        class_unregister(&i2c_adapter_class);
+#ifdef CONFIG_I2C_COMPAT
+        class_compat_unregister(i2c_adapter_compat_class);
 bus_err:
+#endif
         bus_unregister(&i2c_bus_type);
         return retval;
 }
@@ -958,7 +1019,9 @@ bus_err:
 static void __exit i2c_exit(void)
 {
         i2c_del_driver(&dummy_driver);
-        class_unregister(&i2c_adapter_class);
+#ifdef CONFIG_I2C_COMPAT
+        class_compat_unregister(i2c_adapter_compat_class);
+#endif
         bus_unregister(&i2c_bus_type);
 }