[linux-2.6-block.git] / drivers / platform / chrome / chromeos_laptop.c

/*
 *  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
 *
 */

#include <linux/dmi.h>
#include <linux/i2c.h>
#include <linux/i2c/atmel_mxt_ts.h>
#include <linux/input.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/platform_device.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 ISL_ALS_I2C_ADDR	0x44
#define TAOS_ALS_I2C_ADDR	0x29

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",
	"i2c-designware-pci",
	"i2c-designware-pci",
};

/* 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_0,
	I2C_ADAPTER_DESIGNWARE_1,
};

struct i2c_peripheral {
	int (*add)(enum i2c_adapter_type type);
	enum i2c_adapter_type type;
};

#define MAX_I2C_PERIPHERALS 3

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,
};

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,
	.config			= NULL,
	.config_length		= 0,
};

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,
};

static struct mxt_platform_data atmel_1664s_platform_data = {
	.irqflags		= IRQF_TRIGGER_FALLING,
	.config			= NULL,
	.config_length		= 0,
};

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 struct i2c_client *__add_probed_i2c_device(
		const char *name,
		int bus,
		struct i2c_board_info *info,
		const unsigned short *addrs)
{
	const struct dmi_device *dmi_dev;
	const struct dmi_dev_onboard *dev_data;
	struct i2c_adapter *adapter;
	struct i2c_client *client;

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

	/* add the i2c device */
	client = i2c_new_probed_device(adapter, info, addrs, NULL);
	if (!client)
		pr_err("%s failed to register device %d-%02x\n",
		       __func__, bus, info->addr);
	else
		pr_debug("%s added i2c device %d-%02x\n",
			 __func__, bus, 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)
{
	return __add_probed_i2c_device(name,
				       find_i2c_adapter_num(type),
				       info,
				       addrs);
}

/*
 * 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)
{
	const unsigned short addr_list[] = { info->addr, I2C_CLIENT_END };

	return __add_probed_i2c_device(name,
				       find_i2c_adapter_num(type),
				       info,
				       addr_list);
}

static int setup_cyapa_tp(enum i2c_adapter_type type)
{
	if (tp)
		return 0;

	/* add cyapa touchpad */
	tp = add_i2c_device("trackpad", type, &cyapa_device);
	return (!tp) ? -EAGAIN : 0;
}

static int setup_atmel_224s_tp(enum i2c_adapter_type type)
{
	const unsigned short addr_list[] = { ATMEL_TP_I2C_BL_ADDR,
					     ATMEL_TP_I2C_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;
}

static int setup_atmel_1664s_ts(enum i2c_adapter_type type)
{
	const unsigned short addr_list[] = { ATMEL_TS_I2C_BL_ADDR,
					     ATMEL_TS_I2C_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;
}

static int setup_isl29018_als(enum i2c_adapter_type type)
{
	if (als)
		return 0;

	/* add isl29018 light sensor */
	als = add_i2c_device("lightsensor", type, &isl_als_device);
	return (!als) ? -EAGAIN : 0;
}

static int setup_tsl2583_als(enum i2c_adapter_type type)
{
	if (als)
		return 0;

	/* add tsl2583 light sensor */
	als = add_i2c_device(NULL, type, &tsl2583_als_device);
	return (!als) ? -EAGAIN : 0;
}

static int setup_tsl2563_als(enum i2c_adapter_type type)
{
	if (als)
		return 0;

	/* add tsl2563 light sensor */
	als = add_i2c_device(NULL, type, &tsl2563_als_device);
	return (!als) ? -EAGAIN : 0;
}

static int __init chromeos_laptop_dmi_matched(const struct dmi_system_id *id)
{
	cros_laptop = (void *)id->driver_data;
	pr_debug("DMI Matched %s.\n", id->ident);

	/* Indicate to dmi_scan that processing is done. */
	return 1;
}

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;

		/* Add the device. Set -EPROBE_DEFER on any failure */
		if (i2c_dev->add(i2c_dev->type))
			ret = -EPROBE_DEFER;
	}

	return ret;
}

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 chromeos_laptop samsung_series_5 = {
	.i2c_peripherals = {
		/* Light Sensor. */
		{ .add = setup_tsl2583_als, I2C_ADAPTER_SMBUS },
	},
};

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 struct chromeos_laptop hp_chromebook_14 = {
	.i2c_peripherals = {
		/* Touchpad. */
		{ .add = setup_cyapa_tp, I2C_ADAPTER_DESIGNWARE_0 },
	},
};

static struct chromeos_laptop dell_chromebook_11 = {
	.i2c_peripherals = {
		/* Touchpad. */
		{ .add = setup_cyapa_tp, I2C_ADAPTER_DESIGNWARE_0 },
	},
};

static struct chromeos_laptop toshiba_cb35 = {
	.i2c_peripherals = {
		/* Touchpad. */
		{ .add = setup_cyapa_tp, I2C_ADAPTER_DESIGNWARE_0 },
	},
};

static struct chromeos_laptop acer_c7_chromebook = {
	.i2c_peripherals = {
		/* Touchpad. */
		{ .add = setup_cyapa_tp, I2C_ADAPTER_SMBUS },
	},
};

static struct chromeos_laptop acer_ac700 = {
	.i2c_peripherals = {
		/* Light Sensor. */
		{ .add = setup_tsl2563_als, I2C_ADAPTER_SMBUS },
	},
};

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 },
		/* Light Sensor. */
		{ .add = setup_isl29018_als, I2C_ADAPTER_DESIGNWARE_1 },
	},
};

static struct chromeos_laptop hp_pavilion_14_chromebook = {
	.i2c_peripherals = {
		/* Touchpad. */
		{ .add = setup_cyapa_tp, I2C_ADAPTER_SMBUS },
	},
};

static struct chromeos_laptop cr48 = {
	.i2c_peripherals = {
		/* Light Sensor. */
		{ .add = setup_tsl2563_als, I2C_ADAPTER_SMBUS },
	},
};

#define _CBDD(board_) \
	.callback = chromeos_laptop_dmi_matched, \
	.driver_data = (void *)&board_

static struct dmi_system_id chromeos_laptop_dmi_table[] __initdata = {
	{
		.ident = "Samsung Series 5 550",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG"),
			DMI_MATCH(DMI_PRODUCT_NAME, "Lumpy"),
		},
		_CBDD(samsung_series_5_550),
	},
	{
		.ident = "Samsung Series 5",
		.matches = {
			DMI_MATCH(DMI_PRODUCT_NAME, "Alex"),
		},
		_CBDD(samsung_series_5),
	},
	{
		.ident = "Chromebook Pixel",
		.matches = {
			DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"),
			DMI_MATCH(DMI_PRODUCT_NAME, "Link"),
		},
		_CBDD(chromebook_pixel),
	},
	{
		.ident = "Wolf",
		.matches = {
			DMI_MATCH(DMI_BIOS_VENDOR, "coreboot"),
			DMI_MATCH(DMI_PRODUCT_NAME, "Wolf"),
		},
		_CBDD(dell_chromebook_11),
	},
	{
		.ident = "HP Chromebook 14",
		.matches = {
			DMI_MATCH(DMI_BIOS_VENDOR, "coreboot"),
			DMI_MATCH(DMI_PRODUCT_NAME, "Falco"),
		},
		_CBDD(hp_chromebook_14),
	},
	{
		.ident = "Toshiba CB35",
		.matches = {
			DMI_MATCH(DMI_BIOS_VENDOR, "coreboot"),
			DMI_MATCH(DMI_PRODUCT_NAME, "Leon"),
		},
		_CBDD(toshiba_cb35),
	},
	{
		.ident = "Acer C7 Chromebook",
		.matches = {
			DMI_MATCH(DMI_PRODUCT_NAME, "Parrot"),
		},
		_CBDD(acer_c7_chromebook),
	},
	{
		.ident = "Acer AC700",
		.matches = {
			DMI_MATCH(DMI_PRODUCT_NAME, "ZGB"),
		},
		_CBDD(acer_ac700),
	},
	{
		.ident = "Acer C720",
		.matches = {
			DMI_MATCH(DMI_PRODUCT_NAME, "Peppy"),
		},
		_CBDD(acer_c720),
	},
	{
		.ident = "HP Pavilion 14 Chromebook",
		.matches = {
			DMI_MATCH(DMI_PRODUCT_NAME, "Butterfly"),
		},
		_CBDD(hp_pavilion_14_chromebook),
	},
	{
		.ident = "Cr-48",
		.matches = {
			DMI_MATCH(DMI_PRODUCT_NAME, "Mario"),
		},
		_CBDD(cr48),
	},
	{ }
};
MODULE_DEVICE_TABLE(dmi, chromeos_laptop_dmi_table);

static struct platform_device *cros_platform_device;

static struct platform_driver cros_platform_driver = {
	.driver = {
		.name = "chromeos_laptop",
		.owner = THIS_MODULE,
	},
	.probe = chromeos_laptop_probe,
};

static int __init chromeos_laptop_init(void)
{
	int ret;

	if (!dmi_check_system(chromeos_laptop_dmi_table)) {
		pr_debug("%s unsupported system.\n", __func__);
		return -ENODEV;
	}

	ret = platform_driver_register(&cros_platform_driver);
	if (ret)
		return ret;

	cros_platform_device = platform_device_alloc("chromeos_laptop", -1);
	if (!cros_platform_device) {
		ret = -ENOMEM;
		goto fail_platform_device1;
	}

	ret = platform_device_add(cros_platform_device);
	if (ret)
		goto fail_platform_device2;

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

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");
Commit	Line	Data
d1381f45 BL	1	/*
	2	* chromeos_laptop.c - Driver to instantiate Chromebook i2c/smbus devices.
	3	*
	4	* Author : Benson Leung <bleung@chromium.org>
	5	*
	6	* Copyright (C) 2012 Google, Inc.
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; either version 2 of the License, or
	11	* (at your option) any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program; if not, write to the Free Software
	20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	21	*
	22	*/
	23
	24	#include <linux/dmi.h>
	25	#include <linux/i2c.h>
2ef39204 BL	26	#include <linux/i2c/atmel_mxt_ts.h>
	27	#include <linux/input.h>
	28	#include <linux/interrupt.h>
d1381f45	29	#include <linux/module.h>
9ad36924	30	#include <linux/platform_device.h>
d1381f45	31
8e1ad4c4 BL	32	#define ATMEL_TP_I2C_ADDR 0x4b
8e1ad4c4 BL	33	#define ATMEL_TP_I2C_BL_ADDR 0x25
33a84f8a YS	34	#define ATMEL_TS_I2C_ADDR 0x4a
33a84f8a YS	35	#define ATMEL_TS_I2C_BL_ADDR 0x26
d1381f45 BL	36	#define CYAPA_TP_I2C_ADDR 0x67
d1381f45 BL	37	#define ISL_ALS_I2C_ADDR 0x44
aabf3f44	38	#define TAOS_ALS_I2C_ADDR 0x29
d1381f45 BL	39
	40	static struct i2c_client *als;
	41	static struct i2c_client *tp;
33a84f8a	42	static struct i2c_client *ts;
d1381f45	43
6d3c1afe	44	static const char *i2c_adapter_names[] = {
d1381f45	45	"SMBus I801 adapter",
741bf0c7 BL	46	"i915 gmbus vga",
741bf0c7 BL	47	"i915 gmbus panel",
da3b0ab7 MW	48	"i2c-designware-pci",
da3b0ab7 MW	49	"i2c-designware-pci",
d1381f45 BL	50	};
	51
	52	/* Keep this enum consistent with i2c_adapter_names */
	53	enum i2c_adapter_type {
	54	I2C_ADAPTER_SMBUS = 0,
741bf0c7 BL	55	I2C_ADAPTER_VGADDC,
741bf0c7 BL	56	I2C_ADAPTER_PANEL,
da3b0ab7 MW	57	I2C_ADAPTER_DESIGNWARE_0,
da3b0ab7 MW	58	I2C_ADAPTER_DESIGNWARE_1,
d1381f45 BL	59	};
d1381f45 BL	60
ec199dd5	61	struct i2c_peripheral {
9ad36924	62	int (*add)(enum i2c_adapter_type type);
ec199dd5 AD	63	enum i2c_adapter_type type;
	64	};
	65
	66	#define MAX_I2C_PERIPHERALS 3
	67
	68	struct chromeos_laptop {
	69	struct i2c_peripheral i2c_peripherals[MAX_I2C_PERIPHERALS];
	70	};
	71
9ad36924 BL	72	static struct chromeos_laptop *cros_laptop;
	73
	74	static struct i2c_board_info cyapa_device = {
d1381f45 BL	75	I2C_BOARD_INFO("cyapa", CYAPA_TP_I2C_ADDR),
	76	.flags = I2C_CLIENT_WAKE,
	77	};
	78
9ad36924	79	static struct i2c_board_info isl_als_device = {
d1381f45 BL	80	I2C_BOARD_INFO("isl29018", ISL_ALS_I2C_ADDR),
	81	};
	82
9ad36924	83	static struct i2c_board_info tsl2583_als_device = {
8016bcbc BL	84	I2C_BOARD_INFO("tsl2583", TAOS_ALS_I2C_ADDR),
	85	};
	86
9ad36924	87	static struct i2c_board_info tsl2563_als_device = {
aabf3f44 BL	88	I2C_BOARD_INFO("tsl2563", TAOS_ALS_I2C_ADDR),
	89	};
	90
fb5e4c3e ND	91	static int mxt_t19_keys[] = {
	92	KEY_RESERVED,
	93	KEY_RESERVED,
	94	KEY_RESERVED,
	95	KEY_RESERVED,
	96	KEY_RESERVED,
	97	BTN_LEFT
	98	};
	99
2ef39204	100	static struct mxt_platform_data atmel_224s_tp_platform_data = {
2ef39204	101	.irqflags = IRQF_TRIGGER_FALLING,
fb5e4c3e ND	102	.t19_num_keys = ARRAY_SIZE(mxt_t19_keys),
fb5e4c3e ND	103	.t19_keymap = mxt_t19_keys,
2ef39204 BL	104	.config = NULL,
	105	.config_length = 0,
	106	};
	107
9ad36924	108	static struct i2c_board_info atmel_224s_tp_device = {
8e1ad4c4	109	I2C_BOARD_INFO("atmel_mxt_tp", ATMEL_TP_I2C_ADDR),
2ef39204	110	.platform_data = &atmel_224s_tp_platform_data,
8e1ad4c4 BL	111	.flags = I2C_CLIENT_WAKE,
	112	};
	113
2ef39204	114	static struct mxt_platform_data atmel_1664s_platform_data = {
2ef39204	115	.irqflags = IRQF_TRIGGER_FALLING,
2ef39204 BL	116	.config = NULL,
	117	.config_length = 0,
	118	};
	119
9ad36924	120	static struct i2c_board_info atmel_1664s_device = {
33a84f8a	121	I2C_BOARD_INFO("atmel_mxt_ts", ATMEL_TS_I2C_ADDR),
2ef39204	122	.platform_data = &atmel_1664s_platform_data,
33a84f8a YS	123	.flags = I2C_CLIENT_WAKE,
	124	};
	125
9ad36924	126	static struct i2c_client *__add_probed_i2c_device(
d1381f45 BL	127	const char *name,
	128	int bus,
	129	struct i2c_board_info *info,
	130	const unsigned short *addrs)
	131	{
	132	const struct dmi_device *dmi_dev;
	133	const struct dmi_dev_onboard *dev_data;
	134	struct i2c_adapter *adapter;
	135	struct i2c_client *client;
	136
	137	if (bus < 0)
	138	return NULL;
	139	/*
	140	* If a name is specified, look for irq platform information stashed
	141	* in DMI_DEV_TYPE_DEV_ONBOARD by the Chrome OS custom system firmware.
	142	*/
	143	if (name) {
	144	dmi_dev = dmi_find_device(DMI_DEV_TYPE_DEV_ONBOARD, name, NULL);
	145	if (!dmi_dev) {
	146	pr_err("%s failed to dmi find device %s.\n",
	147	__func__,
	148	name);
	149	return NULL;
	150	}
	151	dev_data = (struct dmi_dev_onboard *)dmi_dev->device_data;
	152	if (!dev_data) {
	153	pr_err("%s failed to get data from dmi for %s.\n",
	154	__func__, name);
	155	return NULL;
	156	}
	157	info->irq = dev_data->instance;
	158	}
	159
	160	adapter = i2c_get_adapter(bus);
	161	if (!adapter) {
	162	pr_err("%s failed to get i2c adapter %d.\n", __func__, bus);
	163	return NULL;
	164	}
	165
	166	/* add the i2c device */
	167	client = i2c_new_probed_device(adapter, info, addrs, NULL);
	168	if (!client)
	169	pr_err("%s failed to register device %d-%02x\n",
	170	__func__, bus, info->addr);
	171	else
	172	pr_debug("%s added i2c device %d-%02x\n",
	173	__func__, bus, info->addr);
	174
	175	i2c_put_adapter(adapter);
	176	return client;
	177	}
	178
da3b0ab7 MW	179	struct i2c_lookup {
	180	const char *name;
	181	int instance;
	182	int n;
	183	};
	184
9ad36924	185	static int __find_i2c_adap(struct device dev, void data)
d1381f45	186	{
da3b0ab7	187	struct i2c_lookup *lookup = data;
d1381f45 BL	188	static const char *prefix = "i2c-";
d1381f45 BL	189	struct i2c_adapter *adapter;
49c68a21	190
d1381f45 BL	191	if (strncmp(dev_name(dev), prefix, strlen(prefix)) != 0)
	192	return 0;
	193	adapter = to_i2c_adapter(dev);
da3b0ab7 MW	194	if (strncmp(adapter->name, lookup->name, strlen(lookup->name)) == 0 &&
	195	lookup->n++ == lookup->instance)
	196	return 1;
	197	return 0;
d1381f45 BL	198	}
d1381f45 BL	199
9ad36924	200	static int find_i2c_adapter_num(enum i2c_adapter_type type)
d1381f45 BL	201	{
	202	struct device *dev = NULL;
	203	struct i2c_adapter *adapter;
da3b0ab7 MW	204	struct i2c_lookup lookup;
	205
	206	memset(&lookup, 0, sizeof(lookup));
	207	lookup.name = i2c_adapter_names[type];
	208	lookup.instance = (type == I2C_ADAPTER_DESIGNWARE_1) ? 1 : 0;
	209
d1381f45	210	/* find the adapter by name */
da3b0ab7	211	dev = bus_find_device(&i2c_bus_type, NULL, &lookup, __find_i2c_adap);
d1381f45	212	if (!dev) {
9ad36924 BL	213	/* Adapters may appear later. Deferred probing will retry */
9ad36924 BL	214	pr_notice("%s: i2c adapter %s not found on system.\n", __func__,
da3b0ab7	215	lookup.name);
d1381f45 BL	216	return -ENODEV;
	217	}
	218	adapter = to_i2c_adapter(dev);
	219	return adapter->nr;
	220	}
	221
bcaf089c BL	222	/*
	223	* Takes a list of addresses in addrs as such :
	224	* { addr1, ... , addrn, I2C_CLIENT_END };
	225	* add_probed_i2c_device will use i2c_new_probed_device
	226	* and probe for devices at all of the addresses listed.
	227	* Returns NULL if no devices found.
	228	* See Documentation/i2c/instantiating-devices for more information.
	229	*/
9ad36924	230	static struct i2c_client *add_probed_i2c_device(
bcaf089c BL	231	const char *name,
	232	enum i2c_adapter_type type,
	233	struct i2c_board_info *info,
	234	const unsigned short *addrs)
	235	{
	236	return __add_probed_i2c_device(name,
	237	find_i2c_adapter_num(type),
	238	info,
	239	addrs);
	240	}
	241
d1381f45 BL	242	/*
	243	* Probes for a device at a single address, the one provided by
	244	* info->addr.
	245	* Returns NULL if no device found.
	246	*/
9ad36924	247	static struct i2c_client add_i2c_device(const char name,
e7b28845 BL	248	enum i2c_adapter_type type,
e7b28845 BL	249	struct i2c_board_info *info)
d1381f45 BL	250	{
d1381f45 BL	251	const unsigned short addr_list[] = { info->addr, I2C_CLIENT_END };
49c68a21	252
d1381f45	253	return __add_probed_i2c_device(name,
e7b28845	254	find_i2c_adapter_num(type),
d1381f45 BL	255	info,
	256	addr_list);
	257	}
	258
9ad36924	259	static int setup_cyapa_tp(enum i2c_adapter_type type)
d1381f45	260	{
9ad36924 BL	261	if (tp)
	262	return 0;
	263
ec199dd5 AD	264	/* add cyapa touchpad */
ec199dd5 AD	265	tp = add_i2c_device("trackpad", type, &cyapa_device);
9ad36924	266	return (!tp) ? -EAGAIN : 0;
d1381f45 BL	267	}
d1381f45 BL	268
9ad36924	269	static int setup_atmel_224s_tp(enum i2c_adapter_type type)
8e1ad4c4 BL	270	{
	271	const unsigned short addr_list[] = { ATMEL_TP_I2C_BL_ADDR,
	272	ATMEL_TP_I2C_ADDR,
	273	I2C_CLIENT_END };
9ad36924 BL	274	if (tp)
9ad36924 BL	275	return 0;
8e1ad4c4	276
ec199dd5 AD	277	/* add atmel mxt touchpad */
ec199dd5 AD	278	tp = add_probed_i2c_device("trackpad", type,
8e1ad4c4	279	&atmel_224s_tp_device, addr_list);
9ad36924	280	return (!tp) ? -EAGAIN : 0;
8e1ad4c4 BL	281	}
8e1ad4c4 BL	282
9ad36924	283	static int setup_atmel_1664s_ts(enum i2c_adapter_type type)
33a84f8a YS	284	{
	285	const unsigned short addr_list[] = { ATMEL_TS_I2C_BL_ADDR,
	286	ATMEL_TS_I2C_ADDR,
	287	I2C_CLIENT_END };
9ad36924 BL	288	if (ts)
9ad36924 BL	289	return 0;
33a84f8a	290
ec199dd5 AD	291	/* add atmel mxt touch device */
ec199dd5 AD	292	ts = add_probed_i2c_device("touchscreen", type,
33a84f8a	293	&atmel_1664s_device, addr_list);
9ad36924	294	return (!ts) ? -EAGAIN : 0;
33a84f8a YS	295	}
33a84f8a YS	296
9ad36924	297	static int setup_isl29018_als(enum i2c_adapter_type type)
d1381f45	298	{
9ad36924 BL	299	if (als)
	300	return 0;
	301
d1381f45	302	/* add isl29018 light sensor */
ec199dd5	303	als = add_i2c_device("lightsensor", type, &isl_als_device);
9ad36924	304	return (!als) ? -EAGAIN : 0;
d1381f45 BL	305	}
d1381f45 BL	306
9ad36924	307	static int setup_tsl2583_als(enum i2c_adapter_type type)
cc5c3985	308	{
9ad36924 BL	309	if (als)
	310	return 0;
	311
ec199dd5 AD	312	/* add tsl2583 light sensor */
ec199dd5 AD	313	als = add_i2c_device(NULL, type, &tsl2583_als_device);
9ad36924	314	return (!als) ? -EAGAIN : 0;
cc5c3985 BL	315	}
cc5c3985 BL	316
9ad36924	317	static int setup_tsl2563_als(enum i2c_adapter_type type)
8016bcbc	318	{
9ad36924 BL	319	if (als)
	320	return 0;
	321
ec199dd5 AD	322	/* add tsl2563 light sensor */
ec199dd5 AD	323	als = add_i2c_device(NULL, type, &tsl2563_als_device);
9ad36924	324	return (!als) ? -EAGAIN : 0;
8016bcbc BL	325	}
8016bcbc BL	326
9ad36924	327	static int __init chromeos_laptop_dmi_matched(const struct dmi_system_id *id)
aabf3f44	328	{
9ad36924 BL	329	cros_laptop = (void *)id->driver_data;
9ad36924 BL	330	pr_debug("DMI Matched %s.\n", id->ident);
ec199dd5	331
9ad36924 BL	332	/* Indicate to dmi_scan that processing is done. */
	333	return 1;
	334	}
	335
	336	static int chromeos_laptop_probe(struct platform_device *pdev)
	337	{
	338	int i;
	339	int ret = 0;
ec199dd5 AD	340
	341	for (i = 0; i < MAX_I2C_PERIPHERALS; i++) {
	342	struct i2c_peripheral *i2c_dev;
	343
	344	i2c_dev = &cros_laptop->i2c_peripherals[i];
	345
	346	/* No more peripherals. */
	347	if (i2c_dev->add == NULL)
	348	break;
	349
9ad36924 BL	350	/* Add the device. Set -EPROBE_DEFER on any failure */
	351	if (i2c_dev->add(i2c_dev->type))
	352	ret = -EPROBE_DEFER;
ec199dd5 AD	353	}
ec199dd5 AD	354
9ad36924	355	return ret;
aabf3f44 BL	356	}
aabf3f44 BL	357
9ad36924	358	static struct chromeos_laptop samsung_series_5_550 = {
ec199dd5 AD	359	.i2c_peripherals = {
	360	/* Touchpad. */
	361	{ .add = setup_cyapa_tp, I2C_ADAPTER_SMBUS },
	362	/* Light Sensor. */
	363	{ .add = setup_isl29018_als, I2C_ADAPTER_SMBUS },
	364	},
	365	};
	366
9ad36924	367	static struct chromeos_laptop samsung_series_5 = {
ec199dd5 AD	368	.i2c_peripherals = {
	369	/* Light Sensor. */
	370	{ .add = setup_tsl2583_als, I2C_ADAPTER_SMBUS },
	371	},
	372	};
	373
9ad36924	374	static struct chromeos_laptop chromebook_pixel = {
ec199dd5 AD	375	.i2c_peripherals = {
	376	/* Touch Screen. */
	377	{ .add = setup_atmel_1664s_ts, I2C_ADAPTER_PANEL },
	378	/* Touchpad. */
	379	{ .add = setup_atmel_224s_tp, I2C_ADAPTER_VGADDC },
	380	/* Light Sensor. */
	381	{ .add = setup_isl29018_als, I2C_ADAPTER_PANEL },
	382	},
	383	};
	384
5ea9567f BL	385	static struct chromeos_laptop hp_chromebook_14 = {
	386	.i2c_peripherals = {
	387	/* Touchpad. */
	388	{ .add = setup_cyapa_tp, I2C_ADAPTER_DESIGNWARE_0 },
	389	},
	390	};
	391
0e1e5e59 MH	392	static struct chromeos_laptop dell_chromebook_11 = {
	393	.i2c_peripherals = {
	394	/* Touchpad. */
	395	{ .add = setup_cyapa_tp, I2C_ADAPTER_DESIGNWARE_0 },
	396	},
	397	};
	398
963cb6fa GC	399	static struct chromeos_laptop toshiba_cb35 = {
	400	.i2c_peripherals = {
	401	/* Touchpad. */
	402	{ .add = setup_cyapa_tp, I2C_ADAPTER_DESIGNWARE_0 },
	403	},
	404	};
	405
9ad36924	406	static struct chromeos_laptop acer_c7_chromebook = {
ec199dd5 AD	407	.i2c_peripherals = {
	408	/* Touchpad. */
	409	{ .add = setup_cyapa_tp, I2C_ADAPTER_SMBUS },
	410	},
	411	};
	412
9ad36924	413	static struct chromeos_laptop acer_ac700 = {
ec199dd5 AD	414	.i2c_peripherals = {
	415	/* Light Sensor. */
	416	{ .add = setup_tsl2563_als, I2C_ADAPTER_SMBUS },
	417	},
	418	};
	419
da3b0ab7 MW	420	static struct chromeos_laptop acer_c720 = {
da3b0ab7 MW	421	.i2c_peripherals = {
b90b3c4a MM	422	/* Touchscreen. */
b90b3c4a MM	423	{ .add = setup_atmel_1664s_ts, I2C_ADAPTER_DESIGNWARE_1 },
da3b0ab7 MW	424	/* Touchpad. */
	425	{ .add = setup_cyapa_tp, I2C_ADAPTER_DESIGNWARE_0 },
	426	/* Light Sensor. */
	427	{ .add = setup_isl29018_als, I2C_ADAPTER_DESIGNWARE_1 },
	428	},
	429	};
	430
9ad36924	431	static struct chromeos_laptop hp_pavilion_14_chromebook = {
ec199dd5 AD	432	.i2c_peripherals = {
	433	/* Touchpad. */
	434	{ .add = setup_cyapa_tp, I2C_ADAPTER_SMBUS },
	435	},
	436	};
	437
9ad36924	438	static struct chromeos_laptop cr48 = {
ec199dd5 AD	439	.i2c_peripherals = {
	440	/* Light Sensor. */
	441	{ .add = setup_tsl2563_als, I2C_ADAPTER_SMBUS },
	442	},
	443	};
	444
	445	#define _CBDD(board_) \
9ad36924	446	.callback = chromeos_laptop_dmi_matched, \
ec199dd5 AD	447	.driver_data = (void *)&board_
ec199dd5 AD	448
cdddd23f	449	static struct dmi_system_id chromeos_laptop_dmi_table[] __initdata = {
d1381f45	450	{
ec199dd5	451	.ident = "Samsung Series 5 550",
d1381f45 BL	452	.matches = {
	453	DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG"),
	454	DMI_MATCH(DMI_PRODUCT_NAME, "Lumpy"),
	455	},
ec199dd5	456	_CBDD(samsung_series_5_550),
8e1ad4c4	457	},
d1381f45	458	{
ec199dd5	459	.ident = "Samsung Series 5",
d1381f45	460	.matches = {
ec199dd5	461	DMI_MATCH(DMI_PRODUCT_NAME, "Alex"),
d1381f45	462	},
ec199dd5	463	_CBDD(samsung_series_5),
d1381f45	464	},
cc5c3985	465	{
ec199dd5	466	.ident = "Chromebook Pixel",
cc5c3985 BL	467	.matches = {
	468	DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"),
	469	DMI_MATCH(DMI_PRODUCT_NAME, "Link"),
	470	},
ec199dd5	471	_CBDD(chromebook_pixel),
cc5c3985	472	},
0e1e5e59 MH	473	{
	474	.ident = "Wolf",
	475	.matches = {
	476	DMI_MATCH(DMI_BIOS_VENDOR, "coreboot"),
	477	DMI_MATCH(DMI_PRODUCT_NAME, "Wolf"),
	478	},
	479	_CBDD(dell_chromebook_11),
	480	},
5ea9567f BL	481	{
	482	.ident = "HP Chromebook 14",
	483	.matches = {
	484	DMI_MATCH(DMI_BIOS_VENDOR, "coreboot"),
	485	DMI_MATCH(DMI_PRODUCT_NAME, "Falco"),
	486	},
	487	_CBDD(hp_chromebook_14),
	488	},
963cb6fa GC	489	{
	490	.ident = "Toshiba CB35",
	491	.matches = {
	492	DMI_MATCH(DMI_BIOS_VENDOR, "coreboot"),
	493	DMI_MATCH(DMI_PRODUCT_NAME, "Leon"),
	494	},
	495	_CBDD(toshiba_cb35),
	496	},
261f171f	497	{
ec199dd5	498	.ident = "Acer C7 Chromebook",
261f171f BL	499	.matches = {
	500	DMI_MATCH(DMI_PRODUCT_NAME, "Parrot"),
	501	},
ec199dd5	502	_CBDD(acer_c7_chromebook),
e65a624b BL	503	},
e65a624b BL	504	{
ec199dd5	505	.ident = "Acer AC700",
e65a624b	506	.matches = {
ec199dd5	507	DMI_MATCH(DMI_PRODUCT_NAME, "ZGB"),
e65a624b	508	},
ec199dd5	509	_CBDD(acer_ac700),
261f171f	510	},
da3b0ab7 MW	511	{
	512	.ident = "Acer C720",
	513	.matches = {
	514	DMI_MATCH(DMI_PRODUCT_NAME, "Peppy"),
	515	},
	516	_CBDD(acer_c720),
	517	},
8016bcbc	518	{
ec199dd5	519	.ident = "HP Pavilion 14 Chromebook",
8016bcbc	520	.matches = {
ec199dd5	521	DMI_MATCH(DMI_PRODUCT_NAME, "Butterfly"),
8016bcbc	522	},
ec199dd5	523	_CBDD(hp_pavilion_14_chromebook),
8016bcbc	524	},
aabf3f44	525	{
ec199dd5	526	.ident = "Cr-48",
aabf3f44 BL	527	.matches = {
	528	DMI_MATCH(DMI_PRODUCT_NAME, "Mario"),
	529	},
ec199dd5	530	_CBDD(cr48),
aabf3f44	531	},
d1381f45 BL	532	{ }
	533	};
	534	MODULE_DEVICE_TABLE(dmi, chromeos_laptop_dmi_table);
	535
9ad36924 BL	536	static struct platform_device *cros_platform_device;
	537
	538	static struct platform_driver cros_platform_driver = {
	539	.driver = {
	540	.name = "chromeos_laptop",
	541	.owner = THIS_MODULE,
	542	},
	543	.probe = chromeos_laptop_probe,
	544	};
	545
d1381f45 BL	546	static int __init chromeos_laptop_init(void)
d1381f45 BL	547	{
9ad36924	548	int ret;
49c68a21	549
d1381f45 BL	550	if (!dmi_check_system(chromeos_laptop_dmi_table)) {
	551	pr_debug("%s unsupported system.\n", __func__);
	552	return -ENODEV;
	553	}
9ad36924 BL	554
	555	ret = platform_driver_register(&cros_platform_driver);
	556	if (ret)
	557	return ret;
	558
	559	cros_platform_device = platform_device_alloc("chromeos_laptop", -1);
	560	if (!cros_platform_device) {
	561	ret = -ENOMEM;
	562	goto fail_platform_device1;
	563	}
	564
	565	ret = platform_device_add(cros_platform_device);
	566	if (ret)
	567	goto fail_platform_device2;
	568
d1381f45	569	return 0;
9ad36924 BL	570
	571	fail_platform_device2:
	572	platform_device_put(cros_platform_device);
	573	fail_platform_device1:
	574	platform_driver_unregister(&cros_platform_driver);
	575	return ret;
d1381f45 BL	576	}
	577
	578	static void __exit chromeos_laptop_exit(void)
	579	{
	580	if (als)
	581	i2c_unregister_device(als);
	582	if (tp)
	583	i2c_unregister_device(tp);
33a84f8a YS	584	if (ts)
33a84f8a YS	585	i2c_unregister_device(ts);
2b8454a7 WY	586
	587	platform_device_unregister(cros_platform_device);
	588	platform_driver_unregister(&cros_platform_driver);
d1381f45 BL	589	}
	590
	591	module_init(chromeos_laptop_init);
	592	module_exit(chromeos_laptop_exit);
	593
	594	MODULE_DESCRIPTION("Chrome OS Laptop driver");
	595	MODULE_AUTHOR("Benson Leung <bleung@chromium.org>");
	596	MODULE_LICENSE("GPL");