// 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/acpi.h>
#include <linux/dmi.h>
#include <linux/i2c.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
#define ATMEL_TS_I2C_ADDR       0x4a
#define ATMEL_TS_I2C_BL_ADDR    0x26
#define CYAPA_TP_I2C_ADDR       0x67
#define ELAN_TP_I2C_ADDR        0x15
#define ISL_ALS_I2C_ADDR        0x44
#define TAOS_ALS_I2C_ADDR       0x29

static const char *i2c_adapter_names[] = {
        "SMBus I801 adapter",
        "i915 gmbus vga",
        "i915 gmbus panel",
        "Synopsys DesignWare I2C adapter",
};

/* Keep this enum consistent with i2c_adapter_names */
enum i2c_adapter_type {
        I2C_ADAPTER_SMBUS = 0,
        I2C_ADAPTER_VGADDC,
        I2C_ADAPTER_PANEL,
        I2C_ADAPTER_DESIGNWARE,
};

struct i2c_peripheral {
        struct i2c_board_info board_info;
        unsigned short alt_addr;

        const char *dmi_name;
        unsigned long irqflags;
        struct resource irq_resource;

        enum i2c_adapter_type type;
        u32 pci_devid;

        struct i2c_client *client;
};

struct acpi_peripheral {
        char hid[ACPI_ID_LEN];
        const struct property_entry *properties;
};

struct chromeos_laptop {
        /*
         * Note that we can't mark this pointer as const because
         * i2c_new_scanned_device() changes passed in I2C board info, so.
         */
        struct i2c_peripheral *i2c_peripherals;
        unsigned int num_i2c_peripherals;

        const struct acpi_peripheral *acpi_peripherals;
        unsigned int num_acpi_peripherals;
};

static const struct chromeos_laptop *cros_laptop;

static struct i2c_client *
chromes_laptop_instantiate_i2c_device(struct i2c_adapter *adapter,
                                      struct i2c_board_info *info,
                                      unsigned short alt_addr)
{
        const unsigned short addr_list[] = { info->addr, I2C_CLIENT_END };
        struct i2c_client *client;

        /*
         * Add the i2c device. If we can't detect it at the primary
         * address we scan secondary addresses. In any case the client
         * structure gets assigned primary address.
         */
        client = i2c_new_scanned_device(adapter, info, addr_list, NULL);
        if (IS_ERR(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_scanned_device(adapter, &dummy_info,
                                               alt_addr_list, NULL);
                if (!IS_ERR(dummy)) {
                        pr_debug("%d-%02x is probed at %02x\n",
                                 adapter->nr, info->addr, dummy->addr);
                        i2c_unregister_device(dummy);
                        client = i2c_new_client_device(adapter, info);
                }
        }

        if (IS_ERR(client)) {
                client = NULL;
                pr_debug("failed to register device %d-%02x\n",
                         adapter->nr, info->addr);
        } else {
                pr_debug("added i2c device %d-%02x\n",
                         adapter->nr, info->addr);
        }

        return client;
}

static bool chromeos_laptop_match_adapter_devid(struct device *dev, u32 devid)
{
        struct pci_dev *pdev;

        if (!dev_is_pci(dev))
                return false;

        pdev = to_pci_dev(dev);
        return devid == pci_dev_id(pdev);
}

static void chromeos_laptop_check_adapter(struct i2c_adapter *adapter)
{
        struct i2c_peripheral *i2c_dev;
        int i;

        for (i = 0; i < cros_laptop->num_i2c_peripherals; i++) {
                i2c_dev = &cros_laptop->i2c_peripherals[i];

                /* Skip devices already created */
                if (i2c_dev->client)
                        continue;

                if (strncmp(adapter->name, i2c_adapter_names[i2c_dev->type],
                            strlen(i2c_adapter_names[i2c_dev->type])))
                        continue;

                if (i2c_dev->pci_devid &&
                    !chromeos_laptop_match_adapter_devid(adapter->dev.parent,
                                                         i2c_dev->pci_devid)) {
                        continue;
                }

                i2c_dev->client =
                        chromes_laptop_instantiate_i2c_device(adapter,
                                                        &i2c_dev->board_info,
                                                        i2c_dev->alt_addr);
        }
}

static bool chromeos_laptop_adjust_client(struct i2c_client *client)
{
        const struct acpi_peripheral *acpi_dev;
        struct acpi_device_id acpi_ids[2] = { };
        int i;
        int error;

        if (!has_acpi_companion(&client->dev))
                return false;

        for (i = 0; i < cros_laptop->num_acpi_peripherals; i++) {
                acpi_dev = &cros_laptop->acpi_peripherals[i];

                memcpy(acpi_ids[0].id, acpi_dev->hid, ACPI_ID_LEN);

                if (acpi_match_device(acpi_ids, &client->dev)) {
                        error = device_add_properties(&client->dev,
                                                      acpi_dev->properties);
                        if (error) {
                                dev_err(&client->dev,
                                        "failed to add properties: %d\n",
                                        error);
                                break;
                        }

                        return true;
                }
        }

        return false;
}

static void chromeos_laptop_detach_i2c_client(struct i2c_client *client)
{
        struct i2c_peripheral *i2c_dev;
        int i;

        for (i = 0; i < cros_laptop->num_i2c_peripherals; i++) {
                i2c_dev = &cros_laptop->i2c_peripherals[i];

                if (i2c_dev->client == client)
                        i2c_dev->client = NULL;
        }
}

static int chromeos_laptop_i2c_notifier_call(struct notifier_block *nb,
                                             unsigned long action, void *data)
{
        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));
                else if (dev->type == &i2c_client_type)
                        chromeos_laptop_adjust_client(to_i2c_client(dev));
                break;

        case BUS_NOTIFY_REMOVED_DEVICE:
                if (dev->type == &i2c_client_type)
                        chromeos_laptop_detach_i2c_client(to_i2c_client(dev));
                break;
        }

        return 0;
}

static struct notifier_block chromeos_laptop_i2c_notifier = {
        .notifier_call = chromeos_laptop_i2c_notifier_call,
};

#define DECLARE_CROS_LAPTOP(_name)                                      \
static const struct chromeos_laptop _name __initconst = {               \
        .i2c_peripherals        = _name##_peripherals,                  \
        .num_i2c_peripherals    = ARRAY_SIZE(_name##_peripherals),      \
}

#define DECLARE_ACPI_CROS_LAPTOP(_name)                                 \
static const struct chromeos_laptop _name __initconst = {               \
        .acpi_peripherals       = _name##_peripherals,                  \
        .num_acpi_peripherals   = ARRAY_SIZE(_name##_peripherals),      \
}

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 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 const int chromebook_pixel_tp_keys[] __initconst = {
        KEY_RESERVED,
        KEY_RESERVED,
        KEY_RESERVED,
        KEY_RESERVED,
        KEY_RESERVED,
        BTN_LEFT
};

static const struct property_entry
chromebook_pixel_trackpad_props[] __initconst = {
        PROPERTY_ENTRY_STRING("compatible", "atmel,maxtouch"),
        PROPERTY_ENTRY_U32_ARRAY("linux,gpio-keymap", chromebook_pixel_tp_keys),
        { }
};

static const struct property_entry
chromebook_atmel_touchscreen_props[] __initconst = {
        PROPERTY_ENTRY_STRING("compatible", "atmel,maxtouch"),
        { }
};

static struct i2c_peripheral chromebook_pixel_peripherals[] __initdata = {
        /* Touch Screen. */
        {
                .board_info     = {
                        I2C_BOARD_INFO("atmel_mxt_ts",
                                        ATMEL_TS_I2C_ADDR),
                        .properties     =
                                chromebook_atmel_touchscreen_props,
                        .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 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 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 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 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 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 i2c_peripheral acer_c720_peripherals[] __initdata = {
        /* Touchscreen. */
        {
                .board_info     = {
                        I2C_BOARD_INFO("atmel_mxt_ts",
                                        ATMEL_TS_I2C_ADDR),
                        .properties     =
                                chromebook_atmel_touchscreen_props,
                        .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 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);

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 u32 samus_touchpad_buttons[] __initconst = {
        KEY_RESERVED,
        KEY_RESERVED,
        KEY_RESERVED,
        BTN_LEFT
};

static const struct property_entry samus_trackpad_props[] __initconst = {
        PROPERTY_ENTRY_STRING("compatible", "atmel,maxtouch"),
        PROPERTY_ENTRY_U32_ARRAY("linux,gpio-keymap", samus_touchpad_buttons),
        { }
};

static struct acpi_peripheral samus_peripherals[] __initdata = {
        /* Touchpad */
        {
                .hid            = "ATML0000",
                .properties     = samus_trackpad_props,
        },
        /* Touchsceen */
        {
                .hid            = "ATML0001",
                .properties     = chromebook_atmel_touchscreen_props,
        },
};
DECLARE_ACPI_CROS_LAPTOP(samus);

static struct acpi_peripheral generic_atmel_peripherals[] __initdata = {
        /* Touchpad */
        {
                .hid            = "ATML0000",
                .properties     = chromebook_pixel_trackpad_props,
        },
        /* Touchsceen */
        {
                .hid            = "ATML0001",
                .properties     = chromebook_atmel_touchscreen_props,
        },
};
DECLARE_ACPI_CROS_LAPTOP(generic_atmel);

static const struct dmi_system_id chromeos_laptop_dmi_table[] __initconst = {
        {
                .ident = "Samsung Series 5 550",
                .matches = {
                        DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG"),
                        DMI_MATCH(DMI_PRODUCT_NAME, "Lumpy"),
                },
                .driver_data = (void *)&samsung_series_5_550,
        },
        {
                .ident = "Samsung Series 5",
                .matches = {
                        DMI_MATCH(DMI_PRODUCT_NAME, "Alex"),
                },
                .driver_data = (void *)&samsung_series_5,
        },
        {
                .ident = "Chromebook Pixel",
                .matches = {
                        DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"),
                        DMI_MATCH(DMI_PRODUCT_NAME, "Link"),
                },
                .driver_data = (void *)&chromebook_pixel,
        },
        {
                .ident = "Wolf",
                .matches = {
                        DMI_MATCH(DMI_BIOS_VENDOR, "coreboot"),
                        DMI_MATCH(DMI_PRODUCT_NAME, "Wolf"),
                },
                .driver_data = (void *)&dell_chromebook_11,
        },
        {
                .ident = "HP Chromebook 14",
                .matches = {
                        DMI_MATCH(DMI_BIOS_VENDOR, "coreboot"),
                        DMI_MATCH(DMI_PRODUCT_NAME, "Falco"),
                },
                .driver_data = (void *)&hp_chromebook_14,
        },
        {
                .ident = "Toshiba CB35",
                .matches = {
                        DMI_MATCH(DMI_BIOS_VENDOR, "coreboot"),
                        DMI_MATCH(DMI_PRODUCT_NAME, "Leon"),
                },
                .driver_data = (void *)&toshiba_cb35,
        },
        {
                .ident = "Acer C7 Chromebook",
                .matches = {
                        DMI_MATCH(DMI_PRODUCT_NAME, "Parrot"),
                },
                .driver_data = (void *)&acer_c7_chromebook,
        },
        {
                .ident = "Acer AC700",
                .matches = {
                        DMI_MATCH(DMI_PRODUCT_NAME, "ZGB"),
                },
                .driver_data = (void *)&acer_ac700,
        },
        {
                .ident = "Acer C720",
                .matches = {
                        DMI_MATCH(DMI_PRODUCT_NAME, "Peppy"),
                },
                .driver_data = (void *)&acer_c720,
        },
        {
                .ident = "HP Pavilion 14 Chromebook",
                .matches = {
                        DMI_MATCH(DMI_PRODUCT_NAME, "Butterfly"),
                },
                .driver_data = (void *)&hp_pavilion_14_chromebook,
        },
        {
                .ident = "Cr-48",
                .matches = {
                        DMI_MATCH(DMI_PRODUCT_NAME, "Mario"),
                },
                .driver_data = (void *)&cr48,
        },
        /* Devices with peripherals incompletely described in ACPI */
        {
                .ident = "Chromebook Pro",
                .matches = {
                        DMI_MATCH(DMI_SYS_VENDOR, "Google"),
                        DMI_MATCH(DMI_PRODUCT_NAME, "Caroline"),
                },
                .driver_data = (void *)&samus,
        },
        {
                .ident = "Google Pixel 2 (2015)",
                .matches = {
                        DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"),
                        DMI_MATCH(DMI_PRODUCT_NAME, "Samus"),
                },
                .driver_data = (void *)&samus,
        },
        {
                .ident = "Samsung Chromebook 3",
                .matches = {
                        DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"),
                        DMI_MATCH(DMI_PRODUCT_NAME, "Celes"),
                },
                .driver_data = (void *)&samus,
        },
        {
                /*
                 * Other Chromebooks with Atmel touch controllers:
                 * - Winky (touchpad)
                 * - Clapper, Expresso, Rambi, Glimmer (touchscreen)
                 */
                .ident = "Other Chromebook",
                .matches = {
                        /*
                         * This will match all Google devices, not only devices
                         * with Atmel, but we will validate that the device
                         * actually has matching peripherals.
                         */
                        DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"),
                },
                .driver_data = (void *)&generic_atmel,
        },
        { }
};
MODULE_DEVICE_TABLE(dmi, chromeos_laptop_dmi_table);

static int __init chromeos_laptop_scan_peripherals(struct device *dev, void *data)
{
        int error;

        if (dev->type == &i2c_adapter_type) {
                chromeos_laptop_check_adapter(to_i2c_adapter(dev));
        } else if (dev->type == &i2c_client_type) {
                if (chromeos_laptop_adjust_client(to_i2c_client(dev))) {
                        /*
                         * Now that we have needed properties re-trigger
                         * driver probe in case driver was initialized
                         * earlier and probe failed.
                         */
                        error = device_attach(dev);
                        if (error < 0)
                                dev_warn(dev,
                                         "%s: device_attach() failed: %d\n",
                                         __func__, error);
                }
        }

        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 int __init
chromeos_laptop_prepare_i2c_peripherals(struct chromeos_laptop *cros_laptop,
                                        const struct chromeos_laptop *src)
{
        struct i2c_peripheral *i2c_dev;
        struct i2c_board_info *info;
        int i;
        int error;

        if (!src->num_i2c_peripherals)
                return 0;

        cros_laptop->i2c_peripherals = kmemdup(src->i2c_peripherals,
                                               src->num_i2c_peripherals *
                                                sizeof(*src->i2c_peripherals),
                                               GFP_KERNEL);
        if (!cros_laptop->i2c_peripherals)
                return -ENOMEM;

        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_out;

                /* 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_out;
                        }
                }
        }

        return 0;

err_out:
        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);
        return error;
}

static int __init
chromeos_laptop_prepare_acpi_peripherals(struct chromeos_laptop *cros_laptop,
                                        const struct chromeos_laptop *src)
{
        struct acpi_peripheral *acpi_peripherals;
        struct acpi_peripheral *acpi_dev;
        const struct acpi_peripheral *src_dev;
        int n_peripherals = 0;
        int i;
        int error;

        for (i = 0; i < src->num_acpi_peripherals; i++) {
                if (acpi_dev_present(src->acpi_peripherals[i].hid, NULL, -1))
                        n_peripherals++;
        }

        if (!n_peripherals)
                return 0;

        acpi_peripherals = kcalloc(n_peripherals,
                                   sizeof(*src->acpi_peripherals),
                                   GFP_KERNEL);
        if (!acpi_peripherals)
                return -ENOMEM;

        acpi_dev = acpi_peripherals;
        for (i = 0; i < src->num_acpi_peripherals; i++) {
                src_dev = &src->acpi_peripherals[i];
                if (!acpi_dev_present(src_dev->hid, NULL, -1))
                        continue;

                *acpi_dev = *src_dev;

                /* We need to deep-copy properties */
                if (src_dev->properties) {
                        acpi_dev->properties =
                                property_entries_dup(src_dev->properties);
                        if (IS_ERR(acpi_dev->properties)) {
                                error = PTR_ERR(acpi_dev->properties);
                                goto err_out;
                        }
                }

                acpi_dev++;
        }

        cros_laptop->acpi_peripherals = acpi_peripherals;
        cros_laptop->num_acpi_peripherals = n_peripherals;

        return 0;

err_out:
        while (--i >= 0) {
                acpi_dev = &acpi_peripherals[i];
                if (acpi_dev->properties)
                        property_entries_free(acpi_dev->properties);
        }

        kfree(acpi_peripherals);
        return error;
}

static void chromeos_laptop_destroy(const struct chromeos_laptop *cros_laptop)
{
        const struct acpi_peripheral *acpi_dev;
        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;

                i2c_unregister_device(i2c_dev->client);
                property_entries_free(info->properties);
        }

        for (i = 0; i < cros_laptop->num_acpi_peripherals; i++) {
                acpi_dev = &cros_laptop->acpi_peripherals[i];

                property_entries_free(acpi_dev->properties);
        }

        kfree(cros_laptop->i2c_peripherals);
        kfree(cros_laptop->acpi_peripherals);
        kfree(cros_laptop);
}

static struct chromeos_laptop * __init
chromeos_laptop_prepare(const struct chromeos_laptop *src)
{
        struct chromeos_laptop *cros_laptop;
        int error;

        cros_laptop = kzalloc(sizeof(*cros_laptop), GFP_KERNEL);
        if (!cros_laptop)
                return ERR_PTR(-ENOMEM);

        error = chromeos_laptop_prepare_i2c_peripherals(cros_laptop, src);
        if (!error)
                error = chromeos_laptop_prepare_acpi_peripherals(cros_laptop,
                                                                 src);

        if (error) {
                chromeos_laptop_destroy(cros_laptop);
                return ERR_PTR(error);
        }

        return cros_laptop;
}

static int __init chromeos_laptop_init(void)
{
        const struct dmi_system_id *dmi_id;
        int error;

        dmi_id = dmi_first_match(chromeos_laptop_dmi_table);
        if (!dmi_id) {
                pr_debug("unsupported system\n");
                return -ENODEV;
        }

        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);

        if (!cros_laptop->num_i2c_peripherals &&
            !cros_laptop->num_acpi_peripherals) {
                pr_debug("no relevant devices detected\n");
                error = -ENODEV;
                goto err_destroy_cros_laptop;
        }

        error = bus_register_notifier(&i2c_bus_type,
                                      &chromeos_laptop_i2c_notifier);
        if (error) {
                pr_err("failed to register i2c bus notifier: %d\n",
                       error);
                goto err_destroy_cros_laptop;
        }

        /*
         * Scan adapters that have been registered and clients that have
         * been created before we installed the notifier to make sure
         * we do not miss any devices.
         */
        i2c_for_each_dev(NULL, chromeos_laptop_scan_peripherals);

        return 0;

err_destroy_cros_laptop:
        chromeos_laptop_destroy(cros_laptop);
        return error;
}

static void __exit chromeos_laptop_exit(void)
{
        bus_unregister_notifier(&i2c_bus_type, &chromeos_laptop_i2c_notifier);
        chromeos_laptop_destroy(cros_laptop);
}

module_init(chromeos_laptop_init);
module_exit(chromeos_laptop_exit);

MODULE_DESCRIPTION("Chrome OS Laptop driver");
MODULE_AUTHOR("Benson Leung <bleung@chromium.org>");
MODULE_LICENSE("GPL");