[deliverable/linux.git] / drivers / mfd / cros_ec.c

/*
 * ChromeOS EC multi-function device
 *
 * Copyright (C) 2012 Google, Inc
 *
 * This software is licensed under the terms of the GNU General Public
 * License version 2, as published by the Free Software Foundation, and
 * may be copied, distributed, and modified under those terms.
 *
 * 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.
 *
 * The ChromeOS EC multi function device is used to mux all the requests
 * to the EC device for its multiple features: keyboard controller,
 * battery charging and regulator control, firmware update.
 */

#include <linux/interrupt.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/mfd/core.h>
#include <linux/mfd/cros_ec.h>
#include <linux/mfd/cros_ec_commands.h>
#include <linux/delay.h>

#define EC_COMMAND_RETRIES	50

int cros_ec_prepare_tx(struct cros_ec_device *ec_dev,
		       struct cros_ec_command *msg)
{
	uint8_t *out;
	int csum, i;

	BUG_ON(msg->outsize > EC_PROTO2_MAX_PARAM_SIZE);
	out = ec_dev->dout;
	out[0] = EC_CMD_VERSION0 + msg->version;
	out[1] = msg->command;
	out[2] = msg->outsize;
	csum = out[0] + out[1] + out[2];
	for (i = 0; i < msg->outsize; i++)
		csum += out[EC_MSG_TX_HEADER_BYTES + i] = msg->outdata[i];
	out[EC_MSG_TX_HEADER_BYTES + msg->outsize] = (uint8_t)(csum & 0xff);

	return EC_MSG_TX_PROTO_BYTES + msg->outsize;
}
EXPORT_SYMBOL(cros_ec_prepare_tx);

int cros_ec_check_result(struct cros_ec_device *ec_dev,
			 struct cros_ec_command *msg)
{
	switch (msg->result) {
	case EC_RES_SUCCESS:
		return 0;
	case EC_RES_IN_PROGRESS:
		dev_dbg(ec_dev->dev, "command 0x%02x in progress\n",
			msg->command);
		return -EAGAIN;
	default:
		dev_dbg(ec_dev->dev, "command 0x%02x returned %d\n",
			msg->command, msg->result);
		return 0;
	}
}
EXPORT_SYMBOL(cros_ec_check_result);

int cros_ec_cmd_xfer(struct cros_ec_device *ec_dev,
		     struct cros_ec_command *msg)
{
	int ret;

	mutex_lock(&ec_dev->lock);
	ret = ec_dev->cmd_xfer(ec_dev, msg);
	if (msg->result == EC_RES_IN_PROGRESS) {
		int i;
		struct cros_ec_command status_msg;
		struct ec_response_get_comms_status status;

		status_msg.version = 0;
		status_msg.command = EC_CMD_GET_COMMS_STATUS;
		status_msg.outdata = NULL;
		status_msg.outsize = 0;
		status_msg.indata = (uint8_t *)&status;
		status_msg.insize = sizeof(status);

		/*
		 * Query the EC's status until it's no longer busy or
		 * we encounter an error.
		 */
		for (i = 0; i < EC_COMMAND_RETRIES; i++) {
			usleep_range(10000, 11000);

			ret = ec_dev->cmd_xfer(ec_dev, &status_msg);
			if (ret < 0)
				break;

			msg->result = status_msg.result;
			if (status_msg.result != EC_RES_SUCCESS)
				break;
			if (!(status.flags & EC_COMMS_STATUS_PROCESSING))
				break;
		}
	}
	mutex_unlock(&ec_dev->lock);

	return ret;
}
EXPORT_SYMBOL(cros_ec_cmd_xfer);

static const struct mfd_cell cros_devs[] = {
	{
		.name = "cros-ec-keyb",
		.id = 1,
		.of_compatible = "google,cros-ec-keyb",
	},
	{
		.name = "cros-ec-i2c-tunnel",
		.id = 2,
		.of_compatible = "google,cros-ec-i2c-tunnel",
	},
};

int cros_ec_register(struct cros_ec_device *ec_dev)
{
	struct device *dev = ec_dev->dev;
	int err = 0;

	if (ec_dev->din_size) {
		ec_dev->din = devm_kzalloc(dev, ec_dev->din_size, GFP_KERNEL);
		if (!ec_dev->din)
			return -ENOMEM;
	}
	if (ec_dev->dout_size) {
		ec_dev->dout = devm_kzalloc(dev, ec_dev->dout_size, GFP_KERNEL);
		if (!ec_dev->dout)
			return -ENOMEM;
	}

	mutex_init(&ec_dev->lock);

	err = mfd_add_devices(dev, 0, cros_devs,
			      ARRAY_SIZE(cros_devs),
			      NULL, ec_dev->irq, NULL);
	if (err) {
		dev_err(dev, "failed to add mfd devices\n");
		return err;
	}

	dev_info(dev, "Chrome EC device registered\n");

	return 0;
}
EXPORT_SYMBOL(cros_ec_register);

int cros_ec_remove(struct cros_ec_device *ec_dev)
{
	mfd_remove_devices(ec_dev->dev);

	return 0;
}
EXPORT_SYMBOL(cros_ec_remove);

#ifdef CONFIG_PM_SLEEP
int cros_ec_suspend(struct cros_ec_device *ec_dev)
{
	struct device *dev = ec_dev->dev;

	if (device_may_wakeup(dev))
		ec_dev->wake_enabled = !enable_irq_wake(ec_dev->irq);

	disable_irq(ec_dev->irq);
	ec_dev->was_wake_device = ec_dev->wake_enabled;

	return 0;
}
EXPORT_SYMBOL(cros_ec_suspend);

int cros_ec_resume(struct cros_ec_device *ec_dev)
{
	enable_irq(ec_dev->irq);

	if (ec_dev->wake_enabled) {
		disable_irq_wake(ec_dev->irq);
		ec_dev->wake_enabled = 0;
	}

	return 0;
}
EXPORT_SYMBOL(cros_ec_resume);

#endif

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("ChromeOS EC core driver");
Commit	Line	Data
4ab6174e SG	1	/*
	2	* ChromeOS EC multi-function device
	3	*
	4	* Copyright (C) 2012 Google, Inc
	5	*
	6	* This software is licensed under the terms of the GNU General Public
	7	* License version 2, as published by the Free Software Foundation, and
	8	* may be copied, distributed, and modified under those terms.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	* The ChromeOS EC multi function device is used to mux all the requests
	16	* to the EC device for its multiple features: keyboard controller,
	17	* battery charging and regulator control, firmware update.
	18	*/
	19
	20	#include <linux/interrupt.h>
	21	#include <linux/slab.h>
5ebeaff5	22	#include <linux/module.h>
4ab6174e SG	23	#include <linux/mfd/core.h>
	24	#include <linux/mfd/cros_ec.h>
	25	#include <linux/mfd/cros_ec_commands.h>
d86c21fd AB	26	#include <linux/delay.h>
	27
	28	#define EC_COMMAND_RETRIES 50
4ab6174e SG	29
4ab6174e SG	30	int cros_ec_prepare_tx(struct cros_ec_device *ec_dev,
5d4773e2	31	struct cros_ec_command *msg)
4ab6174e SG	32	{
	33	uint8_t *out;
	34	int csum, i;
	35
5d4773e2	36	BUG_ON(msg->outsize > EC_PROTO2_MAX_PARAM_SIZE);
4ab6174e SG	37	out = ec_dev->dout;
4ab6174e SG	38	out[0] = EC_CMD_VERSION0 + msg->version;
5d4773e2 BR	39	out[1] = msg->command;
5d4773e2 BR	40	out[2] = msg->outsize;
4ab6174e	41	csum = out[0] + out[1] + out[2];
5d4773e2 BR	42	for (i = 0; i < msg->outsize; i++)
	43	csum += out[EC_MSG_TX_HEADER_BYTES + i] = msg->outdata[i];
	44	out[EC_MSG_TX_HEADER_BYTES + msg->outsize] = (uint8_t)(csum & 0xff);
4ab6174e	45
5d4773e2	46	return EC_MSG_TX_PROTO_BYTES + msg->outsize;
4ab6174e	47	}
5ebeaff5	48	EXPORT_SYMBOL(cros_ec_prepare_tx);
4ab6174e	49
6db07b63 BR	50	int cros_ec_check_result(struct cros_ec_device *ec_dev,
	51	struct cros_ec_command *msg)
	52	{
	53	switch (msg->result) {
	54	case EC_RES_SUCCESS:
	55	return 0;
	56	case EC_RES_IN_PROGRESS:
	57	dev_dbg(ec_dev->dev, "command 0x%02x in progress\n",
	58	msg->command);
	59	return -EAGAIN;
	60	default:
	61	dev_dbg(ec_dev->dev, "command 0x%02x returned %d\n",
	62	msg->command, msg->result);
	63	return 0;
	64	}
	65	}
	66	EXPORT_SYMBOL(cros_ec_check_result);
	67
a6551a76 AB	68	int cros_ec_cmd_xfer(struct cros_ec_device *ec_dev,
	69	struct cros_ec_command *msg)
	70	{
63427530 AB	71	int ret;
	72
	73	mutex_lock(&ec_dev->lock);
	74	ret = ec_dev->cmd_xfer(ec_dev, msg);
d86c21fd AB	75	if (msg->result == EC_RES_IN_PROGRESS) {
	76	int i;
	77	struct cros_ec_command status_msg;
	78	struct ec_response_get_comms_status status;
	79
	80	status_msg.version = 0;
	81	status_msg.command = EC_CMD_GET_COMMS_STATUS;
	82	status_msg.outdata = NULL;
	83	status_msg.outsize = 0;
	84	status_msg.indata = (uint8_t *)&status;
	85	status_msg.insize = sizeof(status);
	86
	87	/*
	88	* Query the EC's status until it's no longer busy or
	89	* we encounter an error.
	90	*/
	91	for (i = 0; i < EC_COMMAND_RETRIES; i++) {
	92	usleep_range(10000, 11000);
	93
	94	ret = ec_dev->cmd_xfer(ec_dev, &status_msg);
	95	if (ret < 0)
	96	break;
	97
	98	msg->result = status_msg.result;
	99	if (status_msg.result != EC_RES_SUCCESS)
	100	break;
	101	if (!(status.flags & EC_COMMS_STATUS_PROCESSING))
	102	break;
	103	}
	104	}
63427530 AB	105	mutex_unlock(&ec_dev->lock);
	106
	107	return ret;
a6551a76 AB	108	}
	109	EXPORT_SYMBOL(cros_ec_cmd_xfer);
	110
5ac98553	111	static const struct mfd_cell cros_devs[] = {
4ab6174e SG	112	{
	113	.name = "cros-ec-keyb",
	114	.id = 1,
	115	.of_compatible = "google,cros-ec-keyb",
	116	},
9d230c9e DA	117	{
	118	.name = "cros-ec-i2c-tunnel",
	119	.id = 2,
	120	.of_compatible = "google,cros-ec-i2c-tunnel",
	121	},
4ab6174e SG	122	};
	123
	124	int cros_ec_register(struct cros_ec_device *ec_dev)
	125	{
	126	struct device *dev = ec_dev->dev;
	127	int err = 0;
	128
4ab6174e	129	if (ec_dev->din_size) {
22f9ee75 LJ	130	ec_dev->din = devm_kzalloc(dev, ec_dev->din_size, GFP_KERNEL);
	131	if (!ec_dev->din)
	132	return -ENOMEM;
4ab6174e SG	133	}
4ab6174e SG	134	if (ec_dev->dout_size) {
22f9ee75 LJ	135	ec_dev->dout = devm_kzalloc(dev, ec_dev->dout_size, GFP_KERNEL);
	136	if (!ec_dev->dout)
	137	return -ENOMEM;
4ab6174e SG	138	}
4ab6174e SG	139
63427530 AB	140	mutex_init(&ec_dev->lock);
63427530 AB	141
4ab6174e SG	142	err = mfd_add_devices(dev, 0, cros_devs,
	143	ARRAY_SIZE(cros_devs),
	144	NULL, ec_dev->irq, NULL);
	145	if (err) {
	146	dev_err(dev, "failed to add mfd devices\n");
d1fd345e	147	return err;
4ab6174e SG	148	}
4ab6174e SG	149
533cec8f	150	dev_info(dev, "Chrome EC device registered\n");
4ab6174e SG	151
4ab6174e SG	152	return 0;
4ab6174e	153	}
5ebeaff5	154	EXPORT_SYMBOL(cros_ec_register);
4ab6174e SG	155
	156	int cros_ec_remove(struct cros_ec_device *ec_dev)
	157	{
	158	mfd_remove_devices(ec_dev->dev);
4ab6174e SG	159
	160	return 0;
	161	}
5ebeaff5	162	EXPORT_SYMBOL(cros_ec_remove);
4ab6174e SG	163
	164	#ifdef CONFIG_PM_SLEEP
	165	int cros_ec_suspend(struct cros_ec_device *ec_dev)
	166	{
	167	struct device *dev = ec_dev->dev;
	168
	169	if (device_may_wakeup(dev))
	170	ec_dev->wake_enabled = !enable_irq_wake(ec_dev->irq);
	171
	172	disable_irq(ec_dev->irq);
	173	ec_dev->was_wake_device = ec_dev->wake_enabled;
	174
	175	return 0;
	176	}
5ebeaff5	177	EXPORT_SYMBOL(cros_ec_suspend);
4ab6174e SG	178
	179	int cros_ec_resume(struct cros_ec_device *ec_dev)
	180	{
	181	enable_irq(ec_dev->irq);
	182
	183	if (ec_dev->wake_enabled) {
	184	disable_irq_wake(ec_dev->irq);
	185	ec_dev->wake_enabled = 0;
	186	}
	187
	188	return 0;
	189	}
5ebeaff5 SO	190	EXPORT_SYMBOL(cros_ec_resume);
5ebeaff5 SO	191
4ab6174e	192	#endif
a865a589 BR	193
	194	MODULE_LICENSE("GPL");
	195	MODULE_DESCRIPTION("ChromeOS EC core driver");