Merge remote-tracking branch 'chrome-platform-stop-being-a-platform-driver-plus-atmel_mxt_ts-for-v4.17' into working-branch-for-4.17

4 files changed, 579 insertions, 580 deletions

diff --git a/MAINTAINERS b/MAINTAINERS
index 73c0cdabf755..d4b0b09d2e3f 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -2394,7 +2394,6 @@ T:	git git://github.com/ndyer/linux.git
 S:      Maintained
 F:      Documentation/devicetree/bindings/input/atmel,maxtouch.txt
 F:      drivers/input/touchscreen/atmel_mxt_ts.c
-F:      include/linux/platform_data/atmel_mxt_ts.h
 
 ATMEL SAMA5D2 ADC DRIVER
 M:      Ludovic Desroches <ludovic.desroches@microchip.com>
diff --git a/drivers/input/touchscreen/atmel_mxt_ts.c b/drivers/input/touchscreen/atmel_mxt_ts.c
index 7659bc48f1db..5d9699fe1b55 100644
--- a/drivers/input/touchscreen/atmel_mxt_ts.c
+++ b/drivers/input/touchscreen/atmel_mxt_ts.c
@@ -23,12 +23,13 @@
 #include <linux/delay.h>
 #include <linux/firmware.h>
 #include <linux/i2c.h>
-#include <linux/platform_data/atmel_mxt_ts.h>
 #include <linux/input/mt.h>
 #include <linux/interrupt.h>
 #include <linux/of.h>
+#include <linux/property.h>
 #include <linux/slab.h>
 #include <linux/gpio/consumer.h>
+#include <linux/property.h>
 #include <asm/unaligned.h>
 #include <media/v4l2-device.h>
 #include <media/v4l2-ioctl.h>
@@ -268,12 +269,16 @@ static const struct v4l2_file_operations mxt_video_fops = {
         .poll = vb2_fop_poll,
 };
 
+enum mxt_suspend_mode {
+        MXT_SUSPEND_DEEP_SLEEP  = 0,
+        MXT_SUSPEND_T9_CTRL     = 1,
+};
+
 /* Each client has this additional data */
 struct mxt_data {
         struct i2c_client *client;
         struct input_dev *input_dev;
         char phys[64];          /* device physical location */
-        const struct mxt_platform_data *pdata;
         struct mxt_object *object_table;
         struct mxt_info info;
         unsigned int irq;
@@ -324,6 +329,11 @@ struct mxt_data {
 
         /* for config update handling */
         struct completion crc_completion;
+
+        u32 *t19_keymap;
+        unsigned int t19_num_keys;
+
+        enum mxt_suspend_mode suspend_mode;
 };
 
 struct mxt_vb2_buffer {
@@ -742,15 +752,14 @@ static int mxt_write_object(struct mxt_data *data,
 static void mxt_input_button(struct mxt_data *data, u8 *message)
 {
         struct input_dev *input = data->input_dev;
-        const struct mxt_platform_data *pdata = data->pdata;
         int i;
 
-        for (i = 0; i < pdata->t19_num_keys; i++) {
-                if (pdata->t19_keymap[i] == KEY_RESERVED)
+        for (i = 0; i < data->t19_num_keys; i++) {
+                if (data->t19_keymap[i] == KEY_RESERVED)
                         continue;
 
                 /* Active-low switch */
-                input_report_key(input, pdata->t19_keymap[i],
+                input_report_key(input, data->t19_keymap[i],
                                  !(message[1] & BIT(i)));
         }
 }
@@ -758,7 +767,7 @@ static void mxt_input_button(struct mxt_data *data, u8 *message)
 static void mxt_input_sync(struct mxt_data *data)
 {
         input_mt_report_pointer_emulation(data->input_dev,
-                                          data->pdata->t19_num_keys);
+                                          data->t19_num_keys);
         input_sync(data->input_dev);
 }
 
@@ -1858,7 +1867,6 @@ static void mxt_input_close(struct input_dev *dev);
 static void mxt_set_up_as_touchpad(struct input_dev *input_dev,
                                    struct mxt_data *data)
 {
-        const struct mxt_platform_data *pdata = data->pdata;
         int i;
 
         input_dev->name = "Atmel maXTouch Touchpad";
@@ -1872,15 +1880,14 @@ static void mxt_set_up_as_touchpad(struct input_dev *input_dev,
         input_abs_set_res(input_dev, ABS_MT_POSITION_Y,
                           MXT_PIXELS_PER_MM);
 
-        for (i = 0; i < pdata->t19_num_keys; i++)
-                if (pdata->t19_keymap[i] != KEY_RESERVED)
+        for (i = 0; i < data->t19_num_keys; i++)
+                if (data->t19_keymap[i] != KEY_RESERVED)
                         input_set_capability(input_dev, EV_KEY,
-                                             pdata->t19_keymap[i]);
+                                             data->t19_keymap[i]);
 }
 
 static int mxt_initialize_input_device(struct mxt_data *data)
 {
-        const struct mxt_platform_data *pdata = data->pdata;
         struct device *dev = &data->client->dev;
         struct input_dev *input_dev;
         int error;
@@ -1946,7 +1953,7 @@ static int mxt_initialize_input_device(struct mxt_data *data)
         }
 
         /* If device has buttons we assume it is a touchpad */
-        if (pdata->t19_num_keys) {
+        if (data->t19_num_keys) {
                 mxt_set_up_as_touchpad(input_dev, data);
                 mt_flags |= INPUT_MT_POINTER;
         } else {
@@ -2868,7 +2875,7 @@ static const struct attribute_group mxt_attr_group = {
 
 static void mxt_start(struct mxt_data *data)
 {
-        switch (data->pdata->suspend_mode) {
+        switch (data->suspend_mode) {
         case MXT_SUSPEND_T9_CTRL:
                 mxt_soft_reset(data);
 
@@ -2886,12 +2893,11 @@ static void mxt_start(struct mxt_data *data)
                 mxt_t6_command(data, MXT_COMMAND_CALIBRATE, 1, false);
                 break;
         }
-
 }
 
 static void mxt_stop(struct mxt_data *data)
 {
-        switch (data->pdata->suspend_mode) {
+        switch (data->suspend_mode) {
         case MXT_SUSPEND_T9_CTRL:
                 /* Touch disable */
                 mxt_write_object(data,
@@ -2921,55 +2927,49 @@ static void mxt_input_close(struct input_dev *dev)
         mxt_stop(data);
 }
 
-#ifdef CONFIG_OF
-static const struct mxt_platform_data *mxt_parse_dt(struct i2c_client *client)
+static int mxt_parse_device_properties(struct mxt_data *data)
 {
-        struct mxt_platform_data *pdata;
-        struct device_node *np = client->dev.of_node;
+        static const char keymap_property[] = "linux,gpio-keymap";
+        struct device *dev = &data->client->dev;
         u32 *keymap;
-        int proplen, ret;
-
-        if (!np)
-                return ERR_PTR(-ENOENT);
-
-        pdata = devm_kzalloc(&client->dev, sizeof(*pdata), GFP_KERNEL);
-        if (!pdata)
-                return ERR_PTR(-ENOMEM);
+        int n_keys;
+        int error;
 
-        if (of_find_property(np, "linux,gpio-keymap", &proplen)) {
-                pdata->t19_num_keys = proplen / sizeof(u32);
+        if (device_property_present(dev, keymap_property)) {
+                n_keys = device_property_read_u32_array(dev, keymap_property,
+                                                        NULL, 0);
+                if (n_keys <= 0) {
+                        error = n_keys < 0 ? n_keys : -EINVAL;
+                        dev_err(dev, "invalid/malformed '%s' property: %d\n",
+                                keymap_property, error);
+                        return error;
+                }
 
-                keymap = devm_kzalloc(&client->dev,
-                                pdata->t19_num_keys * sizeof(keymap[0]),
-                                GFP_KERNEL);
+                keymap = devm_kmalloc_array(dev, n_keys, sizeof(*keymap),
+                                            GFP_KERNEL);
                 if (!keymap)
-                        return ERR_PTR(-ENOMEM);
+                        return -ENOMEM;
 
-                ret = of_property_read_u32_array(np, "linux,gpio-keymap",
-                                                 keymap, pdata->t19_num_keys);
-                if (ret)
-                        dev_warn(&client->dev,
-                                 "Couldn't read linux,gpio-keymap: %d\n", ret);
+                error = device_property_read_u32_array(dev, keymap_property,
+                                                       keymap, n_keys);
+                if (error) {
+                        dev_err(dev, "failed to parse '%s' property: %d\n",
+                                keymap_property, error);
+                        return error;
+                }
 
-                pdata->t19_keymap = keymap;
+                data->t19_keymap = keymap;
+                data->t19_num_keys = n_keys;
         }
 
-        pdata->suspend_mode = MXT_SUSPEND_DEEP_SLEEP;
-
-        return pdata;
-}
-#else
-static const struct mxt_platform_data *mxt_parse_dt(struct i2c_client *client)
-{
-        return ERR_PTR(-ENOENT);
+        return 0;
 }
-#endif
 
 #ifdef CONFIG_ACPI
 
 struct mxt_acpi_platform_data {
         const char *hid;
-        struct mxt_platform_data pdata;
+        const struct property_entry *props;
 };
 
 static unsigned int samus_touchpad_buttons[] = {
@@ -2979,14 +2979,16 @@ static unsigned int samus_touchpad_buttons[] = {
         BTN_LEFT
 };
 
+static const struct property_entry samus_touchpad_props[] = {
+        PROPERTY_ENTRY_U32_ARRAY("linux,gpio-keymap", samus_touchpad_buttons),
+        { }
+};
+
 static struct mxt_acpi_platform_data samus_platform_data[] = {
         {
                 /* Touchpad */
                 .hid    = "ATML0000",
-                .pdata  = {
-                        .t19_num_keys   = ARRAY_SIZE(samus_touchpad_buttons),
-                        .t19_keymap     = samus_touchpad_buttons,
-                },
+                .props  = samus_touchpad_props,
         },
         {
                 /* Touchscreen */
@@ -3004,14 +3006,16 @@ static unsigned int chromebook_tp_buttons[] = {
         BTN_LEFT
 };
 
+static const struct property_entry chromebook_tp_props[] = {
+        PROPERTY_ENTRY_U32_ARRAY("linux,gpio-keymap", chromebook_tp_buttons),
+        { }
+};
+
 static struct mxt_acpi_platform_data chromebook_platform_data[] = {
         {
                 /* Touchpad */
                 .hid    = "ATML0000",
-                .pdata  = {
-                        .t19_num_keys   = ARRAY_SIZE(chromebook_tp_buttons),
-                        .t19_keymap     = chromebook_tp_buttons,
-                },
+                .props  = chromebook_tp_props,
         },
         {
                 /* Touchscreen */
@@ -3041,83 +3045,85 @@ static const struct dmi_system_id mxt_dmi_table[] = {
         { }
 };
 
-static const struct mxt_platform_data *mxt_parse_acpi(struct i2c_client *client)
+static int mxt_prepare_acpi_properties(struct i2c_client *client)
 {
         struct acpi_device *adev;
         const struct dmi_system_id *system_id;
         const struct mxt_acpi_platform_data *acpi_pdata;
 
-        /*
-         * Ignore ACPI devices representing bootloader mode.
-         *
-         * This is a bit of a hack: Google Chromebook BIOS creates ACPI
-         * devices for both application and bootloader modes, but we are
-         * interested in application mode only (if device is in bootloader
-         * mode we'll end up switching into application anyway). So far
-         * application mode addresses were all above 0x40, so we'll use it
-         * as a threshold.
-         */
-        if (client->addr < 0x40)
-                return ERR_PTR(-ENXIO);
-
         adev = ACPI_COMPANION(&client->dev);
         if (!adev)
-                return ERR_PTR(-ENOENT);
+                return -ENOENT;
 
         system_id = dmi_first_match(mxt_dmi_table);
         if (!system_id)
-                return ERR_PTR(-ENOENT);
+                return -ENOENT;
 
         acpi_pdata = system_id->driver_data;
         if (!acpi_pdata)
-                return ERR_PTR(-ENOENT);
+                return -ENOENT;
 
         while (acpi_pdata->hid) {
-                if (!strcmp(acpi_device_hid(adev), acpi_pdata->hid))
-                        return &acpi_pdata->pdata;
+                if (!strcmp(acpi_device_hid(adev), acpi_pdata->hid)) {
+                        /*
+                         * Remove previously installed properties if we
+                         * are probing this device not for the very first
+                         * time.
+                         */
+                        device_remove_properties(&client->dev);
+
+                        /*
+                         * Now install the platform-specific properties
+                         * that are missing from ACPI.
+                         */
+                        device_add_properties(&client->dev, acpi_pdata->props);
+                        break;
+                }
 
                 acpi_pdata++;
         }
 
-        return ERR_PTR(-ENOENT);
+        return 0;
 }
 #else
-static const struct mxt_platform_data *mxt_parse_acpi(struct i2c_client *client)
+static int mxt_prepare_acpi_properties(struct i2c_client *client)
 {
-        return ERR_PTR(-ENOENT);
+        return -ENOENT;
 }
 #endif
 
-static const struct mxt_platform_data *
-mxt_get_platform_data(struct i2c_client *client)
-{
-        const struct mxt_platform_data *pdata;
-
-        pdata = dev_get_platdata(&client->dev);
-        if (pdata)
-                return pdata;
-
-        pdata = mxt_parse_dt(client);
-        if (!IS_ERR(pdata) || PTR_ERR(pdata) != -ENOENT)
-                return pdata;
-
-        pdata = mxt_parse_acpi(client);
-        if (!IS_ERR(pdata) || PTR_ERR(pdata) != -ENOENT)
-                return pdata;
-
-        dev_err(&client->dev, "No platform data specified\n");
-        return ERR_PTR(-EINVAL);
-}
+static const struct dmi_system_id chromebook_T9_suspend_dmi[] = {
+        {
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Link"),
+                },
+        },
+        {
+                .matches = {
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Peppy"),
+                },
+        },
+        { }
+};
 
 static int mxt_probe(struct i2c_client *client, const struct i2c_device_id *id)
 {
         struct mxt_data *data;
-        const struct mxt_platform_data *pdata;
         int error;
 
-        pdata = mxt_get_platform_data(client);
-        if (IS_ERR(pdata))
-                return PTR_ERR(pdata);
+        /*
+         * Ignore ACPI devices representing bootloader mode.
+         *
+         * This is a bit of a hack: Google Chromebook BIOS creates ACPI
+         * devices for both application and bootloader modes, but we are
+         * interested in application mode only (if device is in bootloader
+         * mode we'll end up switching into application anyway). So far
+         * application mode addresses were all above 0x40, so we'll use it
+         * as a threshold.
+         */
+        if (ACPI_COMPANION(&client->dev) && client->addr < 0x40)
+                return -ENXIO;
 
         data = devm_kzalloc(&client->dev, sizeof(struct mxt_data), GFP_KERNEL);
         if (!data)
@@ -3127,7 +3133,6 @@ static int mxt_probe(struct i2c_client *client, const struct i2c_device_id *id)
                  client->adapter->nr, client->addr);
 
         data->client = client;
-        data->pdata = pdata;
         data->irq = client->irq;
         i2c_set_clientdata(client, data);
 
@@ -3135,6 +3140,17 @@ static int mxt_probe(struct i2c_client *client, const struct i2c_device_id *id)
         init_completion(&data->reset_completion);
         init_completion(&data->crc_completion);
 
+        data->suspend_mode = dmi_check_system(chromebook_T9_suspend_dmi) ?
+                MXT_SUSPEND_T9_CTRL : MXT_SUSPEND_DEEP_SLEEP;
+
+        error = mxt_prepare_acpi_properties(client);
+        if (error && error != -ENOENT)
+                return error;
+
+        error = mxt_parse_device_properties(data);
+        if (error)
+                return error;
+
         data->reset_gpio = devm_gpiod_get_optional(&client->dev,
                                                    "reset", GPIOD_OUT_LOW);
         if (IS_ERR(data->reset_gpio)) {
@@ -3144,8 +3160,7 @@ static int mxt_probe(struct i2c_client *client, const struct i2c_device_id *id)
         }
 
         error = devm_request_threaded_irq(&client->dev, client->irq,
-                                          NULL, mxt_interrupt,
-                                          pdata->irqflags | IRQF_ONESHOT,
+                                          NULL, mxt_interrupt, IRQF_ONESHOT,
                                           client->name, data);
         if (error) {
                 dev_err(&client->dev, "Failed to register interrupt\n");
@@ -3265,7 +3280,7 @@ MODULE_DEVICE_TABLE(i2c, mxt_id);
 static struct i2c_driver mxt_driver = {
         .driver = {
                 .name   = "atmel_mxt_ts",
-                .of_match_table = of_match_ptr(mxt_of_match),
+                .of_match_table = mxt_of_match,
                 .acpi_match_table = ACPI_PTR(mxt_acpi_id),
                 .pm     = &mxt_pm_ops,
         },
diff --git a/drivers/platform/chrome/chromeos_laptop.c b/drivers/platform/chrome/chromeos_laptop.c
index d8599736a41a..5c47f451e43b 100644
--- a/drivers/platform/chrome/chromeos_laptop.c
+++ b/drivers/platform/chrome/chromeos_laptop.c
@@ -1,33 +1,20 @@
-/*
- *  chromeos_laptop.c - Driver to instantiate Chromebook i2c/smbus devices.
- *
- *  Author : Benson Leung <bleung@chromium.org>
- *
- *  Copyright (C) 2012 Google, Inc.
- *
- *  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- *
- */
+// SPDX-License-Identifier: GPL-2.0+
+// Driver to instantiate Chromebook i2c/smbus devices.
+//
+// Copyright (C) 2012 Google, Inc.
+// Author: Benson Leung <bleung@chromium.org>
+
+#define pr_fmt(fmt)             KBUILD_MODNAME ": " fmt
 
 #include <linux/dmi.h>
 #include <linux/i2c.h>
-#include <linux/platform_data/atmel_mxt_ts.h>
 #include <linux/input.h>
 #include <linux/interrupt.h>
+#include <linux/ioport.h>
 #include <linux/module.h>
+#include <linux/pci.h>
 #include <linux/platform_device.h>
+#include <linux/property.h>
 
 #define ATMEL_TP_I2C_ADDR       0x4b
 #define ATMEL_TP_I2C_BL_ADDR    0x25
@@ -38,18 +25,11 @@
 #define ISL_ALS_I2C_ADDR        0x44
 #define TAOS_ALS_I2C_ADDR       0x29
 
-#define MAX_I2C_DEVICE_DEFERRALS        5
-
-static struct i2c_client *als;
-static struct i2c_client *tp;
-static struct i2c_client *ts;
-
 static const char *i2c_adapter_names[] = {
         "SMBus I801 adapter",
         "i915 gmbus vga",
         "i915 gmbus panel",
         "Synopsys DesignWare I2C adapter",
-        "Synopsys DesignWare I2C adapter",
 };
 
 /* Keep this enum consistent with i2c_adapter_names */
@@ -57,126 +37,41 @@ enum i2c_adapter_type {
         I2C_ADAPTER_SMBUS = 0,
         I2C_ADAPTER_VGADDC,
         I2C_ADAPTER_PANEL,
-        I2C_ADAPTER_DESIGNWARE_0,
-        I2C_ADAPTER_DESIGNWARE_1,
-};
-
-enum i2c_peripheral_state {
-        UNPROBED = 0,
-        PROBED,
-        TIMEDOUT,
+        I2C_ADAPTER_DESIGNWARE,
 };
 
 struct i2c_peripheral {
-        int (*add)(enum i2c_adapter_type type);
-        enum i2c_adapter_type type;
-        enum i2c_peripheral_state state;
-        int tries;
-};
-
-#define MAX_I2C_PERIPHERALS 4
+        struct i2c_board_info board_info;
+        unsigned short alt_addr;
 
-struct chromeos_laptop {
-        struct i2c_peripheral i2c_peripherals[MAX_I2C_PERIPHERALS];
-};
-
-static struct chromeos_laptop *cros_laptop;
-
-static struct i2c_board_info cyapa_device = {
-        I2C_BOARD_INFO("cyapa", CYAPA_TP_I2C_ADDR),
-        .flags          = I2C_CLIENT_WAKE,
-};
+        const char *dmi_name;
+        unsigned long irqflags;
+        struct resource irq_resource;
 
-static struct i2c_board_info elantech_device = {
-        I2C_BOARD_INFO("elan_i2c", ELAN_TP_I2C_ADDR),
-        .flags          = I2C_CLIENT_WAKE,
-};
-
-static struct i2c_board_info isl_als_device = {
-        I2C_BOARD_INFO("isl29018", ISL_ALS_I2C_ADDR),
-};
-
-static struct i2c_board_info tsl2583_als_device = {
-        I2C_BOARD_INFO("tsl2583", TAOS_ALS_I2C_ADDR),
-};
-
-static struct i2c_board_info tsl2563_als_device = {
-        I2C_BOARD_INFO("tsl2563", TAOS_ALS_I2C_ADDR),
-};
-
-static int mxt_t19_keys[] = {
-        KEY_RESERVED,
-        KEY_RESERVED,
-        KEY_RESERVED,
-        KEY_RESERVED,
-        KEY_RESERVED,
-        BTN_LEFT
-};
-
-static struct mxt_platform_data atmel_224s_tp_platform_data = {
-        .irqflags               = IRQF_TRIGGER_FALLING,
-        .t19_num_keys           = ARRAY_SIZE(mxt_t19_keys),
-        .t19_keymap             = mxt_t19_keys,
-        .suspend_mode           = MXT_SUSPEND_T9_CTRL,
-};
+        enum i2c_adapter_type type;
+        u32 pci_devid;
 
-static struct i2c_board_info atmel_224s_tp_device = {
-        I2C_BOARD_INFO("atmel_mxt_tp", ATMEL_TP_I2C_ADDR),
-        .platform_data = &atmel_224s_tp_platform_data,
-        .flags          = I2C_CLIENT_WAKE,
+        struct i2c_client *client;
 };
 
-static struct mxt_platform_data atmel_1664s_platform_data = {
-        .irqflags               = IRQF_TRIGGER_FALLING,
-        .suspend_mode           = MXT_SUSPEND_T9_CTRL,
+struct chromeos_laptop {
+        /*
+         * Note that we can't mark this pointer as const because
+         * i2c_new_probed_device() changes passed in I2C board info, so.
+         */
+        struct i2c_peripheral *i2c_peripherals;
+        unsigned int num_i2c_peripherals;
 };
 
-static struct i2c_board_info atmel_1664s_device = {
-        I2C_BOARD_INFO("atmel_mxt_ts", ATMEL_TS_I2C_ADDR),
-        .platform_data = &atmel_1664s_platform_data,
-        .flags          = I2C_CLIENT_WAKE,
-};
+static const struct chromeos_laptop *cros_laptop;
 
-static struct i2c_client *__add_probed_i2c_device(
-                const char *name,
-                int bus,
-                struct i2c_board_info *info,
-                const unsigned short *alt_addr_list)
+static struct i2c_client *
+chromes_laptop_instantiate_i2c_device(struct i2c_adapter *adapter,
+                                      struct i2c_board_info *info,
+                                      unsigned short alt_addr)
 {
-        const struct dmi_device *dmi_dev;
-        const struct dmi_dev_onboard *dev_data;
-        struct i2c_adapter *adapter;
-        struct i2c_client *client = NULL;
         const unsigned short addr_list[] = { info->addr, I2C_CLIENT_END };
-
-        if (bus < 0)
-                return NULL;
-        /*
-         * If a name is specified, look for irq platform information stashed
-         * in DMI_DEV_TYPE_DEV_ONBOARD by the Chrome OS custom system firmware.
-         */
-        if (name) {
-                dmi_dev = dmi_find_device(DMI_DEV_TYPE_DEV_ONBOARD, name, NULL);
-                if (!dmi_dev) {
-                        pr_err("%s failed to dmi find device %s.\n",
-                               __func__,
-                               name);
-                        return NULL;
-                }
-                dev_data = (struct dmi_dev_onboard *)dmi_dev->device_data;
-                if (!dev_data) {
-                        pr_err("%s failed to get data from dmi for %s.\n",
-                               __func__, name);
-                        return NULL;
-                }
-                info->irq = dev_data->instance;
-        }
-
-        adapter = i2c_get_adapter(bus);
-        if (!adapter) {
-                pr_err("%s failed to get i2c adapter %d.\n", __func__, bus);
-                return NULL;
-        }
+        struct i2c_client *client;
 
         /*
          * Add the i2c device. If we can't detect it at the primary
@@ -184,339 +79,345 @@ static struct i2c_client *__add_probed_i2c_device(
          * structure gets assigned primary address.
          */
         client = i2c_new_probed_device(adapter, info, addr_list, NULL);
-        if (!client && alt_addr_list) {
+        if (!client && alt_addr) {
                 struct i2c_board_info dummy_info = {
                         I2C_BOARD_INFO("dummy", info->addr),
                 };
+                const unsigned short alt_addr_list[] = {
+                        alt_addr, I2C_CLIENT_END
+                };
                 struct i2c_client *dummy;
 
                 dummy = i2c_new_probed_device(adapter, &dummy_info,
                                               alt_addr_list, NULL);
                 if (dummy) {
-                        pr_debug("%s %d-%02x is probed at %02x\n",
-                                  __func__, bus, info->addr, dummy->addr);
+                        pr_debug("%d-%02x is probed at %02x\n",
+                                 adapter->nr, info->addr, dummy->addr);
                         i2c_unregister_device(dummy);
                         client = i2c_new_device(adapter, info);
                 }
         }
 
         if (!client)
-                pr_notice("%s failed to register device %d-%02x\n",
-                          __func__, bus, info->addr);
+                pr_debug("failed to register device %d-%02x\n",
+                         adapter->nr, info->addr);
         else
-                pr_debug("%s added i2c device %d-%02x\n",
-                         __func__, bus, info->addr);
+                pr_debug("added i2c device %d-%02x\n",
+                         adapter->nr, info->addr);
 
-        i2c_put_adapter(adapter);
         return client;
 }
 
-struct i2c_lookup {
-        const char *name;
-        int instance;
-        int n;
-};
-
-static int __find_i2c_adap(struct device *dev, void *data)
-{
-        struct i2c_lookup *lookup = data;
-        static const char *prefix = "i2c-";
-        struct i2c_adapter *adapter;
-
-        if (strncmp(dev_name(dev), prefix, strlen(prefix)) != 0)
-                return 0;
-        adapter = to_i2c_adapter(dev);
-        if (strncmp(adapter->name, lookup->name, strlen(lookup->name)) == 0 &&
-            lookup->n++ == lookup->instance)
-                return 1;
-        return 0;
-}
-
-static int find_i2c_adapter_num(enum i2c_adapter_type type)
-{
-        struct device *dev = NULL;
-        struct i2c_adapter *adapter;
-        struct i2c_lookup lookup;
-
-        memset(&lookup, 0, sizeof(lookup));
-        lookup.name = i2c_adapter_names[type];
-        lookup.instance = (type == I2C_ADAPTER_DESIGNWARE_1) ? 1 : 0;
-
-        /* find the adapter by name */
-        dev = bus_find_device(&i2c_bus_type, NULL, &lookup, __find_i2c_adap);
-        if (!dev) {
-                /* Adapters may appear later. Deferred probing will retry */
-                pr_notice("%s: i2c adapter %s not found on system.\n", __func__,
-                          lookup.name);
-                return -ENODEV;
-        }
-        adapter = to_i2c_adapter(dev);
-        return adapter->nr;
-}
-
-/*
- * Takes a list of addresses in addrs as such :
- * { addr1, ... , addrn, I2C_CLIENT_END };
- * add_probed_i2c_device will use i2c_new_probed_device
- * and probe for devices at all of the addresses listed.
- * Returns NULL if no devices found.
- * See Documentation/i2c/instantiating-devices for more information.
- */
-static struct i2c_client *add_probed_i2c_device(
-                const char *name,
-                enum i2c_adapter_type type,
-                struct i2c_board_info *info,
-                const unsigned short *addrs)
+static bool chromeos_laptop_match_adapter_devid(struct device *dev, u32 devid)
 {
-        return __add_probed_i2c_device(name,
-                                       find_i2c_adapter_num(type),
-                                       info,
-                                       addrs);
-}
+        struct pci_dev *pdev;
 
-/*
- * Probes for a device at a single address, the one provided by
- * info->addr.
- * Returns NULL if no device found.
- */
-static struct i2c_client *add_i2c_device(const char *name,
-                                                enum i2c_adapter_type type,
-                                                struct i2c_board_info *info)
-{
-        return __add_probed_i2c_device(name,
-                                       find_i2c_adapter_num(type),
-                                       info,
-                                       NULL);
-}
-
-static int setup_cyapa_tp(enum i2c_adapter_type type)
-{
-        if (tp)
-                return 0;
+        if (!dev_is_pci(dev))
+                return false;
 
-        /* add cyapa touchpad */
-        tp = add_i2c_device("trackpad", type, &cyapa_device);
-        return (!tp) ? -EAGAIN : 0;
+        pdev = to_pci_dev(dev);
+        return devid == PCI_DEVID(pdev->bus->number, pdev->devfn);
 }
 
-static int setup_atmel_224s_tp(enum i2c_adapter_type type)
+static void chromeos_laptop_check_adapter(struct i2c_adapter *adapter)
 {
-        const unsigned short addr_list[] = { ATMEL_TP_I2C_BL_ADDR,
-                                             I2C_CLIENT_END };
-        if (tp)
-                return 0;
-
-        /* add atmel mxt touchpad */
-        tp = add_probed_i2c_device("trackpad", type,
-                                   &atmel_224s_tp_device, addr_list);
-        return (!tp) ? -EAGAIN : 0;
-}
+        struct i2c_peripheral *i2c_dev;
+        int i;
 
-static int setup_elantech_tp(enum i2c_adapter_type type)
-{
-        if (tp)
-                return 0;
+        for (i = 0; i < cros_laptop->num_i2c_peripherals; i++) {
+                i2c_dev = &cros_laptop->i2c_peripherals[i];
 
-        /* add elantech touchpad */
-        tp = add_i2c_device("trackpad", type, &elantech_device);
-        return (!tp) ? -EAGAIN : 0;
-}
+                /* Skip devices already created */
+                if (i2c_dev->client)
+                        continue;
 
-static int setup_atmel_1664s_ts(enum i2c_adapter_type type)
-{
-        const unsigned short addr_list[] = { ATMEL_TS_I2C_BL_ADDR,
-                                             I2C_CLIENT_END };
-        if (ts)
-                return 0;
-
-        /* add atmel mxt touch device */
-        ts = add_probed_i2c_device("touchscreen", type,
-                                   &atmel_1664s_device, addr_list);
-        return (!ts) ? -EAGAIN : 0;
-}
+                if (strncmp(adapter->name, i2c_adapter_names[i2c_dev->type],
+                            strlen(i2c_adapter_names[i2c_dev->type])))
+                        continue;
 
-static int setup_isl29018_als(enum i2c_adapter_type type)
-{
-        if (als)
-                return 0;
+                if (i2c_dev->pci_devid &&
+                    !chromeos_laptop_match_adapter_devid(adapter->dev.parent,
+                                                         i2c_dev->pci_devid)) {
+                        continue;
+                }
 
-        /* add isl29018 light sensor */
-        als = add_i2c_device("lightsensor", type, &isl_als_device);
-        return (!als) ? -EAGAIN : 0;
+                i2c_dev->client =
+                        chromes_laptop_instantiate_i2c_device(adapter,
+                                                        &i2c_dev->board_info,
+                                                        i2c_dev->alt_addr);
+        }
 }
 
-static int setup_tsl2583_als(enum i2c_adapter_type type)
+static void chromeos_laptop_detach_i2c_client(struct i2c_client *client)
 {
-        if (als)
-                return 0;
-
-        /* add tsl2583 light sensor */
-        als = add_i2c_device(NULL, type, &tsl2583_als_device);
-        return (!als) ? -EAGAIN : 0;
-}
+        struct i2c_peripheral *i2c_dev;
+        int i;
 
-static int setup_tsl2563_als(enum i2c_adapter_type type)
-{
-        if (als)
-                return 0;
+        for (i = 0; i < cros_laptop->num_i2c_peripherals; i++) {
+                i2c_dev = &cros_laptop->i2c_peripherals[i];
 
-        /* add tsl2563 light sensor */
-        als = add_i2c_device(NULL, type, &tsl2563_als_device);
-        return (!als) ? -EAGAIN : 0;
+                if (i2c_dev->client == client)
+                        i2c_dev->client = NULL;
+        }
 }
 
-static int __init chromeos_laptop_dmi_matched(const struct dmi_system_id *id)
+static int chromeos_laptop_i2c_notifier_call(struct notifier_block *nb,
+                                             unsigned long action, void *data)
 {
-        cros_laptop = (void *)id->driver_data;
-        pr_debug("DMI Matched %s.\n", id->ident);
+        struct device *dev = data;
+
+        switch (action) {
+        case BUS_NOTIFY_ADD_DEVICE:
+                if (dev->type == &i2c_adapter_type)
+                        chromeos_laptop_check_adapter(to_i2c_adapter(dev));
+                break;
+
+        case BUS_NOTIFY_REMOVED_DEVICE:
+                if (dev->type == &i2c_client_type)
+                        chromeos_laptop_detach_i2c_client(to_i2c_client(dev));
+                break;
+        }
 
-        /* Indicate to dmi_scan that processing is done. */
-        return 1;
+        return 0;
 }
 
-static int chromeos_laptop_probe(struct platform_device *pdev)
-{
-        int i;
-        int ret = 0;
-
-        for (i = 0; i < MAX_I2C_PERIPHERALS; i++) {
-                struct i2c_peripheral *i2c_dev;
-
-                i2c_dev = &cros_laptop->i2c_peripherals[i];
-
-                /* No more peripherals. */
-                if (i2c_dev->add == NULL)
-                        break;
-
-                if (i2c_dev->state == TIMEDOUT || i2c_dev->state == PROBED)
-                        continue;
-
-                /*
-                 * Check that the i2c adapter is present.
-                 * -EPROBE_DEFER if missing as the adapter may appear much
-                 * later.
-                 */
-                if (find_i2c_adapter_num(i2c_dev->type) == -ENODEV) {
-                        ret = -EPROBE_DEFER;
-                        continue;
-                }
-
-                /* Add the device. */
-                if (i2c_dev->add(i2c_dev->type) == -EAGAIN) {
-                        /*
-                         * Set -EPROBE_DEFER a limited num of times
-                         * if device is not successfully added.
-                         */
-                        if (++i2c_dev->tries < MAX_I2C_DEVICE_DEFERRALS) {
-                                ret = -EPROBE_DEFER;
-                        } else {
-                                /* Ran out of tries. */
-                                pr_notice("%s: Ran out of tries for device.\n",
-                                          __func__);
-                                i2c_dev->state = TIMEDOUT;
-                        }
-                } else {
-                        i2c_dev->state = PROBED;
-                }
-        }
+static struct notifier_block chromeos_laptop_i2c_notifier = {
+        .notifier_call = chromeos_laptop_i2c_notifier_call,
+};
 
-        return ret;
+#define DECLARE_CROS_LAPTOP(_name)                                      \
+static const struct chromeos_laptop _name __initconst = {               \
+        .i2c_peripherals        = _name##_peripherals,                  \
+        .num_i2c_peripherals    = ARRAY_SIZE(_name##_peripherals),      \
 }
 
-static struct chromeos_laptop samsung_series_5_550 = {
-        .i2c_peripherals = {
-                /* Touchpad. */
-                { .add = setup_cyapa_tp, I2C_ADAPTER_SMBUS },
-                /* Light Sensor. */
-                { .add = setup_isl29018_als, I2C_ADAPTER_SMBUS },
+static struct i2c_peripheral samsung_series_5_550_peripherals[] __initdata = {
+        /* Touchpad. */
+        {
+                .board_info     = {
+                        I2C_BOARD_INFO("cyapa", CYAPA_TP_I2C_ADDR),
+                        .flags          = I2C_CLIENT_WAKE,
+                },
+                .dmi_name       = "trackpad",
+                .type           = I2C_ADAPTER_SMBUS,
+        },
+        /* Light Sensor. */
+        {
+                .board_info     = {
+                        I2C_BOARD_INFO("isl29018", ISL_ALS_I2C_ADDR),
+                },
+                .dmi_name       = "lightsensor",
+                .type           = I2C_ADAPTER_SMBUS,
         },
 };
+DECLARE_CROS_LAPTOP(samsung_series_5_550);
 
-static struct chromeos_laptop samsung_series_5 = {
-        .i2c_peripherals = {
-                /* Light Sensor. */
-                { .add = setup_tsl2583_als, I2C_ADAPTER_SMBUS },
+static struct i2c_peripheral samsung_series_5_peripherals[] __initdata = {
+        /* Light Sensor. */
+        {
+                .board_info     = {
+                        I2C_BOARD_INFO("tsl2583", TAOS_ALS_I2C_ADDR),
+                },
+                .type           = I2C_ADAPTER_SMBUS,
         },
 };
+DECLARE_CROS_LAPTOP(samsung_series_5);
 
-static struct chromeos_laptop chromebook_pixel = {
-        .i2c_peripherals = {
-                /* Touch Screen. */
-                { .add = setup_atmel_1664s_ts, I2C_ADAPTER_PANEL },
-                /* Touchpad. */
-                { .add = setup_atmel_224s_tp, I2C_ADAPTER_VGADDC },
-                /* Light Sensor. */
-                { .add = setup_isl29018_als, I2C_ADAPTER_PANEL },
-        },
+static const int chromebook_pixel_tp_keys[] __initconst = {
+        KEY_RESERVED,
+        KEY_RESERVED,
+        KEY_RESERVED,
+        KEY_RESERVED,
+        KEY_RESERVED,
+        BTN_LEFT
 };
 
-static struct chromeos_laptop hp_chromebook_14 = {
-        .i2c_peripherals = {
-                /* Touchpad. */
-                { .add = setup_cyapa_tp, I2C_ADAPTER_DESIGNWARE_0 },
+static const struct property_entry
+chromebook_pixel_trackpad_props[] __initconst = {
+        PROPERTY_ENTRY_U32_ARRAY("linux,gpio-keymap", chromebook_pixel_tp_keys),
+        { }
+};
+
+static struct i2c_peripheral chromebook_pixel_peripherals[] __initdata = {
+        /* Touch Screen. */
+        {
+                .board_info     = {
+                        I2C_BOARD_INFO("atmel_mxt_ts",
+                                        ATMEL_TS_I2C_ADDR),
+                        .flags          = I2C_CLIENT_WAKE,
+                },
+                .dmi_name       = "touchscreen",
+                .irqflags       = IRQF_TRIGGER_FALLING,
+                .type           = I2C_ADAPTER_PANEL,
+                .alt_addr       = ATMEL_TS_I2C_BL_ADDR,
+        },
+        /* Touchpad. */
+        {
+                .board_info     = {
+                        I2C_BOARD_INFO("atmel_mxt_tp",
+                                        ATMEL_TP_I2C_ADDR),
+                        .properties     =
+                                chromebook_pixel_trackpad_props,
+                        .flags          = I2C_CLIENT_WAKE,
+                },
+                .dmi_name       = "trackpad",
+                .irqflags       = IRQF_TRIGGER_FALLING,
+                .type           = I2C_ADAPTER_VGADDC,
+                .alt_addr       = ATMEL_TP_I2C_BL_ADDR,
+        },
+        /* Light Sensor. */
+        {
+                .board_info     = {
+                        I2C_BOARD_INFO("isl29018", ISL_ALS_I2C_ADDR),
+                },
+                .dmi_name       = "lightsensor",
+                .type           = I2C_ADAPTER_PANEL,
         },
 };
+DECLARE_CROS_LAPTOP(chromebook_pixel);
 
-static struct chromeos_laptop dell_chromebook_11 = {
-        .i2c_peripherals = {
-                /* Touchpad. */
-                { .add = setup_cyapa_tp, I2C_ADAPTER_DESIGNWARE_0 },
-                /* Elan Touchpad option. */
-                { .add = setup_elantech_tp, I2C_ADAPTER_DESIGNWARE_0 },
+static struct i2c_peripheral hp_chromebook_14_peripherals[] __initdata = {
+        /* Touchpad. */
+        {
+                .board_info     = {
+                        I2C_BOARD_INFO("cyapa", CYAPA_TP_I2C_ADDR),
+                        .flags          = I2C_CLIENT_WAKE,
+                },
+                .dmi_name       = "trackpad",
+                .type           = I2C_ADAPTER_DESIGNWARE,
         },
 };
+DECLARE_CROS_LAPTOP(hp_chromebook_14);
 
-static struct chromeos_laptop toshiba_cb35 = {
-        .i2c_peripherals = {
-                /* Touchpad. */
-                { .add = setup_cyapa_tp, I2C_ADAPTER_DESIGNWARE_0 },
+static struct i2c_peripheral dell_chromebook_11_peripherals[] __initdata = {
+        /* Touchpad. */
+        {
+                .board_info     = {
+                        I2C_BOARD_INFO("cyapa", CYAPA_TP_I2C_ADDR),
+                        .flags          = I2C_CLIENT_WAKE,
+                },
+                .dmi_name       = "trackpad",
+                .type           = I2C_ADAPTER_DESIGNWARE,
+        },
+        /* Elan Touchpad option. */
+        {
+                .board_info     = {
+                        I2C_BOARD_INFO("elan_i2c", ELAN_TP_I2C_ADDR),
+                        .flags          = I2C_CLIENT_WAKE,
+                },
+                .dmi_name       = "trackpad",
+                .type           = I2C_ADAPTER_DESIGNWARE,
         },
 };
+DECLARE_CROS_LAPTOP(dell_chromebook_11);
 
-static struct chromeos_laptop acer_c7_chromebook = {
-        .i2c_peripherals = {
-                /* Touchpad. */
-                { .add = setup_cyapa_tp, I2C_ADAPTER_SMBUS },
+static struct i2c_peripheral toshiba_cb35_peripherals[] __initdata = {
+        /* Touchpad. */
+        {
+                .board_info     = {
+                        I2C_BOARD_INFO("cyapa", CYAPA_TP_I2C_ADDR),
+                        .flags          = I2C_CLIENT_WAKE,
+                },
+                .dmi_name       = "trackpad",
+                .type           = I2C_ADAPTER_DESIGNWARE,
         },
 };
+DECLARE_CROS_LAPTOP(toshiba_cb35);
 
-static struct chromeos_laptop acer_ac700 = {
-        .i2c_peripherals = {
-                /* Light Sensor. */
-                { .add = setup_tsl2563_als, I2C_ADAPTER_SMBUS },
+static struct i2c_peripheral acer_c7_chromebook_peripherals[] __initdata = {
+        /* Touchpad. */
+        {
+                .board_info     = {
+                        I2C_BOARD_INFO("cyapa", CYAPA_TP_I2C_ADDR),
+                        .flags          = I2C_CLIENT_WAKE,
+                },
+                .dmi_name       = "trackpad",
+                .type           = I2C_ADAPTER_SMBUS,
         },
 };
+DECLARE_CROS_LAPTOP(acer_c7_chromebook);
 
-static struct chromeos_laptop acer_c720 = {
-        .i2c_peripherals = {
-                /* Touchscreen. */
-                { .add = setup_atmel_1664s_ts, I2C_ADAPTER_DESIGNWARE_1 },
-                /* Touchpad. */
-                { .add = setup_cyapa_tp, I2C_ADAPTER_DESIGNWARE_0 },
-                /* Elan Touchpad option. */
-                { .add = setup_elantech_tp, I2C_ADAPTER_DESIGNWARE_0 },
-                /* Light Sensor. */
-                { .add = setup_isl29018_als, I2C_ADAPTER_DESIGNWARE_1 },
+static struct i2c_peripheral acer_ac700_peripherals[] __initdata = {
+        /* Light Sensor. */
+        {
+                .board_info     = {
+                        I2C_BOARD_INFO("tsl2583", TAOS_ALS_I2C_ADDR),
+                },
+                .type           = I2C_ADAPTER_SMBUS,
         },
 };
+DECLARE_CROS_LAPTOP(acer_ac700);
 
-static struct chromeos_laptop hp_pavilion_14_chromebook = {
-        .i2c_peripherals = {
-                /* Touchpad. */
-                { .add = setup_cyapa_tp, I2C_ADAPTER_SMBUS },
+static struct i2c_peripheral acer_c720_peripherals[] __initdata = {
+        /* Touchscreen. */
+        {
+                .board_info     = {
+                        I2C_BOARD_INFO("atmel_mxt_ts",
+                                        ATMEL_TS_I2C_ADDR),
+                        .flags          = I2C_CLIENT_WAKE,
+                },
+                .dmi_name       = "touchscreen",
+                .irqflags       = IRQF_TRIGGER_FALLING,
+                .type           = I2C_ADAPTER_DESIGNWARE,
+                .pci_devid      = PCI_DEVID(0, PCI_DEVFN(0x15, 0x2)),
+                .alt_addr       = ATMEL_TS_I2C_BL_ADDR,
+        },
+        /* Touchpad. */
+        {
+                .board_info     = {
+                        I2C_BOARD_INFO("cyapa", CYAPA_TP_I2C_ADDR),
+                        .flags          = I2C_CLIENT_WAKE,
+                },
+                .dmi_name       = "trackpad",
+                .type           = I2C_ADAPTER_DESIGNWARE,
+                .pci_devid      = PCI_DEVID(0, PCI_DEVFN(0x15, 0x1)),
+        },
+        /* Elan Touchpad option. */
+        {
+                .board_info     = {
+                        I2C_BOARD_INFO("elan_i2c", ELAN_TP_I2C_ADDR),
+                        .flags          = I2C_CLIENT_WAKE,
+                },
+                .dmi_name       = "trackpad",
+                .type           = I2C_ADAPTER_DESIGNWARE,
+                .pci_devid      = PCI_DEVID(0, PCI_DEVFN(0x15, 0x1)),
+        },
+        /* Light Sensor. */
+        {
+                .board_info     = {
+                        I2C_BOARD_INFO("isl29018", ISL_ALS_I2C_ADDR),
+                },
+                .dmi_name       = "lightsensor",
+                .type           = I2C_ADAPTER_DESIGNWARE,
+                .pci_devid      = PCI_DEVID(0, PCI_DEVFN(0x15, 0x2)),
         },
 };
+DECLARE_CROS_LAPTOP(acer_c720);
 
-static struct chromeos_laptop cr48 = {
-        .i2c_peripherals = {
-                /* Light Sensor. */
-                { .add = setup_tsl2563_als, I2C_ADAPTER_SMBUS },
+static struct i2c_peripheral
+hp_pavilion_14_chromebook_peripherals[] __initdata = {
+        /* Touchpad. */
+        {
+                .board_info     = {
+                        I2C_BOARD_INFO("cyapa", CYAPA_TP_I2C_ADDR),
+                        .flags          = I2C_CLIENT_WAKE,
+                },
+                .dmi_name       = "trackpad",
+                .type           = I2C_ADAPTER_SMBUS,
         },
 };
+DECLARE_CROS_LAPTOP(hp_pavilion_14_chromebook);
 
-#define _CBDD(board_) \
-        .callback = chromeos_laptop_dmi_matched, \
-        .driver_data = (void *)&board_
+static struct i2c_peripheral cr48_peripherals[] __initdata = {
+        /* Light Sensor. */
+        {
+                .board_info     = {
+                        I2C_BOARD_INFO("tsl2563", TAOS_ALS_I2C_ADDR),
+                },
+                .type           = I2C_ADAPTER_SMBUS,
+        },
+};
+DECLARE_CROS_LAPTOP(cr48);
 
 static const struct dmi_system_id chromeos_laptop_dmi_table[] __initconst = {
         {
@@ -525,14 +426,14 @@ static const struct dmi_system_id chromeos_laptop_dmi_table[] __initconst = {
                         DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG"),
                         DMI_MATCH(DMI_PRODUCT_NAME, "Lumpy"),
                 },
-                _CBDD(samsung_series_5_550),
+                .driver_data = (void *)&samsung_series_5_550,
         },
         {
                 .ident = "Samsung Series 5",
                 .matches = {
                         DMI_MATCH(DMI_PRODUCT_NAME, "Alex"),
                 },
-                _CBDD(samsung_series_5),
+                .driver_data = (void *)&samsung_series_5,
         },
         {
                 .ident = "Chromebook Pixel",
@@ -540,7 +441,7 @@ static const struct dmi_system_id chromeos_laptop_dmi_table[] __initconst = {
                         DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"),
                         DMI_MATCH(DMI_PRODUCT_NAME, "Link"),
                 },
-                _CBDD(chromebook_pixel),
+                .driver_data = (void *)&chromebook_pixel,
         },
         {
                 .ident = "Wolf",
@@ -548,7 +449,7 @@ static const struct dmi_system_id chromeos_laptop_dmi_table[] __initconst = {
                         DMI_MATCH(DMI_BIOS_VENDOR, "coreboot"),
                         DMI_MATCH(DMI_PRODUCT_NAME, "Wolf"),
                 },
-                _CBDD(dell_chromebook_11),
+                .driver_data = (void *)&dell_chromebook_11,
         },
         {
                 .ident = "HP Chromebook 14",
@@ -556,7 +457,7 @@ static const struct dmi_system_id chromeos_laptop_dmi_table[] __initconst = {
                         DMI_MATCH(DMI_BIOS_VENDOR, "coreboot"),
                         DMI_MATCH(DMI_PRODUCT_NAME, "Falco"),
                 },
-                _CBDD(hp_chromebook_14),
+                .driver_data = (void *)&hp_chromebook_14,
         },
         {
                 .ident = "Toshiba CB35",
@@ -564,99 +465,214 @@ static const struct dmi_system_id chromeos_laptop_dmi_table[] __initconst = {
                         DMI_MATCH(DMI_BIOS_VENDOR, "coreboot"),
                         DMI_MATCH(DMI_PRODUCT_NAME, "Leon"),
                 },
-                _CBDD(toshiba_cb35),
+                .driver_data = (void *)&toshiba_cb35,
         },
         {
                 .ident = "Acer C7 Chromebook",
                 .matches = {
                         DMI_MATCH(DMI_PRODUCT_NAME, "Parrot"),
                 },
-                _CBDD(acer_c7_chromebook),
+                .driver_data = (void *)&acer_c7_chromebook,
         },
         {
                 .ident = "Acer AC700",
                 .matches = {
                         DMI_MATCH(DMI_PRODUCT_NAME, "ZGB"),
                 },
-                _CBDD(acer_ac700),
+                .driver_data = (void *)&acer_ac700,
         },
         {
                 .ident = "Acer C720",
                 .matches = {
                         DMI_MATCH(DMI_PRODUCT_NAME, "Peppy"),
                 },
-                _CBDD(acer_c720),
+                .driver_data = (void *)&acer_c720,
         },
         {
                 .ident = "HP Pavilion 14 Chromebook",
                 .matches = {
                         DMI_MATCH(DMI_PRODUCT_NAME, "Butterfly"),
                 },
-                _CBDD(hp_pavilion_14_chromebook),
+                .driver_data = (void *)&hp_pavilion_14_chromebook,
         },
         {
                 .ident = "Cr-48",
                 .matches = {
                         DMI_MATCH(DMI_PRODUCT_NAME, "Mario"),
                 },
-                _CBDD(cr48),
+                .driver_data = (void *)&cr48,
         },
         { }
 };
 MODULE_DEVICE_TABLE(dmi, chromeos_laptop_dmi_table);
 
-static struct platform_device *cros_platform_device;
+static int __init chromeos_laptop_scan_adapter(struct device *dev, void *data)
+{
+        struct i2c_adapter *adapter;
 
-static struct platform_driver cros_platform_driver = {
-        .driver = {
-                .name = "chromeos_laptop",
-        },
-        .probe = chromeos_laptop_probe,
-};
+        adapter = i2c_verify_adapter(dev);
+        if (adapter)
+                chromeos_laptop_check_adapter(adapter);
+
+        return 0;
+}
+
+static int __init chromeos_laptop_get_irq_from_dmi(const char *dmi_name)
+{
+        const struct dmi_device *dmi_dev;
+        const struct dmi_dev_onboard *dev_data;
+
+        dmi_dev = dmi_find_device(DMI_DEV_TYPE_DEV_ONBOARD, dmi_name, NULL);
+        if (!dmi_dev) {
+                pr_err("failed to find DMI device '%s'\n", dmi_name);
+                return -ENOENT;
+        }
+
+        dev_data = dmi_dev->device_data;
+        if (!dev_data) {
+                pr_err("failed to get data from DMI for '%s'\n", dmi_name);
+                return -EINVAL;
+        }
+
+        return dev_data->instance;
+}
+
+static int __init chromeos_laptop_setup_irq(struct i2c_peripheral *i2c_dev)
+{
+        int irq;
+
+        if (i2c_dev->dmi_name) {
+                irq = chromeos_laptop_get_irq_from_dmi(i2c_dev->dmi_name);
+                if (irq < 0)
+                        return irq;
+
+                i2c_dev->irq_resource  = (struct resource)
+                        DEFINE_RES_NAMED(irq, 1, NULL,
+                                         IORESOURCE_IRQ | i2c_dev->irqflags);
+                i2c_dev->board_info.resources = &i2c_dev->irq_resource;
+                i2c_dev->board_info.num_resources = 1;
+        }
+
+        return 0;
+}
+
+static struct chromeos_laptop * __init
+chromeos_laptop_prepare(const struct chromeos_laptop *src)
+{
+        struct chromeos_laptop *cros_laptop;
+        struct i2c_peripheral *i2c_dev;
+        struct i2c_board_info *info;
+        int error;
+        int i;
+
+        cros_laptop = kzalloc(sizeof(*cros_laptop), GFP_KERNEL);
+        if (!cros_laptop)
+                return ERR_PTR(-ENOMEM);
+
+        cros_laptop->i2c_peripherals = kmemdup(src->i2c_peripherals,
+                                               src->num_i2c_peripherals *
+                                                sizeof(*src->i2c_peripherals),
+                                               GFP_KERNEL);
+        if (!cros_laptop->i2c_peripherals) {
+                error = -ENOMEM;
+                goto err_free_cros_laptop;
+        }
+
+        cros_laptop->num_i2c_peripherals = src->num_i2c_peripherals;
+
+        for (i = 0; i < cros_laptop->num_i2c_peripherals; i++) {
+                i2c_dev = &cros_laptop->i2c_peripherals[i];
+                info = &i2c_dev->board_info;
+
+                error = chromeos_laptop_setup_irq(i2c_dev);
+                if (error)
+                        goto err_destroy_cros_peripherals;
+
+                /* We need to deep-copy properties */
+                if (info->properties) {
+                        info->properties =
+                                property_entries_dup(info->properties);
+                        if (IS_ERR(info->properties)) {
+                                error = PTR_ERR(info->properties);
+                                goto err_destroy_cros_peripherals;
+                        }
+                }
+        }
+
+        return cros_laptop;
+
+err_destroy_cros_peripherals:
+        while (--i >= 0) {
+                i2c_dev = &cros_laptop->i2c_peripherals[i];
+                info = &i2c_dev->board_info;
+                if (info->properties)
+                        property_entries_free(info->properties);
+        }
+        kfree(cros_laptop->i2c_peripherals);
+err_free_cros_laptop:
+        kfree(cros_laptop);
+        return ERR_PTR(error);
+}
+
+static void chromeos_laptop_destroy(const struct chromeos_laptop *cros_laptop)
+{
+        struct i2c_peripheral *i2c_dev;
+        struct i2c_board_info *info;
+        int i;
+
+        for (i = 0; i < cros_laptop->num_i2c_peripherals; i++) {
+                i2c_dev = &cros_laptop->i2c_peripherals[i];
+                info = &i2c_dev->board_info;
+
+                if (i2c_dev->client)
+                        i2c_unregister_device(i2c_dev->client);
+
+                if (info->properties)
+                        property_entries_free(info->properties);
+        }
+
+        kfree(cros_laptop->i2c_peripherals);
+        kfree(cros_laptop);
+}
 
 static int __init chromeos_laptop_init(void)
 {
-        int ret;
+        const struct dmi_system_id *dmi_id;
+        int error;
 
-        if (!dmi_check_system(chromeos_laptop_dmi_table)) {
-                pr_debug("%s unsupported system.\n", __func__);
+        dmi_id = dmi_first_match(chromeos_laptop_dmi_table);
+        if (!dmi_id) {
+                pr_debug("unsupported system\n");
                 return -ENODEV;
         }
 
-        ret = platform_driver_register(&cros_platform_driver);
-        if (ret)
-                return ret;
+        pr_debug("DMI Matched %s\n", dmi_id->ident);
+
+        cros_laptop = chromeos_laptop_prepare((void *)dmi_id->driver_data);
+        if (IS_ERR(cros_laptop))
+                return PTR_ERR(cros_laptop);
 
-        cros_platform_device = platform_device_alloc("chromeos_laptop", -1);
-        if (!cros_platform_device) {
-                ret = -ENOMEM;
-                goto fail_platform_device1;
+        error = bus_register_notifier(&i2c_bus_type,
+                                      &chromeos_laptop_i2c_notifier);
+        if (error) {
+                pr_err("failed to register i2c bus notifier: %d\n", error);
+                chromeos_laptop_destroy(cros_laptop);
+                return error;
         }
 
-        ret = platform_device_add(cros_platform_device);
-        if (ret)
-                goto fail_platform_device2;
+        /*
+         * Scan adapters that have been registered before we installed
+         * the notifier to make sure we do not miss any devices.
+         */
+        i2c_for_each_dev(NULL, chromeos_laptop_scan_adapter);
 
         return 0;
-
-fail_platform_device2:
-        platform_device_put(cros_platform_device);
-fail_platform_device1:
-        platform_driver_unregister(&cros_platform_driver);
-        return ret;
 }
 
 static void __exit chromeos_laptop_exit(void)
 {
-        if (als)
-                i2c_unregister_device(als);
-        if (tp)
-                i2c_unregister_device(tp);
-        if (ts)
-                i2c_unregister_device(ts);
-
-        platform_device_unregister(cros_platform_device);
-        platform_driver_unregister(&cros_platform_driver);
+        bus_unregister_notifier(&i2c_bus_type, &chromeos_laptop_i2c_notifier);
+        chromeos_laptop_destroy(cros_laptop);
 }
 
 module_init(chromeos_laptop_init);
diff --git a/include/linux/platform_data/atmel_mxt_ts.h b/include/linux/platform_data/atmel_mxt_ts.h
deleted file mode 100644
index 695035a8d7fb..000000000000
--- a/include/linux/platform_data/atmel_mxt_ts.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * Atmel maXTouch Touchscreen driver
- *
- * Copyright (C) 2010 Samsung Electronics Co.Ltd
- * Author: Joonyoung Shim <jy0922.shim@samsung.com>
- *
- * This program is free software; you can redistribute  it and/or modify it
- * under  the terms of  the GNU General  Public License as published by the
- * Free Software Foundation;  either version 2 of the  License, or (at your
- * option) any later version.
- */
-
-#ifndef __LINUX_PLATFORM_DATA_ATMEL_MXT_TS_H
-#define __LINUX_PLATFORM_DATA_ATMEL_MXT_TS_H
-
-#include <linux/types.h>
-
-enum mxt_suspend_mode {
-        MXT_SUSPEND_DEEP_SLEEP  = 0,
-        MXT_SUSPEND_T9_CTRL     = 1,
-};
-
-/* The platform data for the Atmel maXTouch touchscreen driver */
-struct mxt_platform_data {
-        unsigned long irqflags;
-        u8 t19_num_keys;
-        const unsigned int *t19_keymap;
-        enum mxt_suspend_mode suspend_mode;
-};
-
-#endif /* __LINUX_PLATFORM_DATA_ATMEL_MXT_TS_H */