cros: add LPC support for cros_ec

This patch adds LPC support for carrying out the cros_ec protocol. Signed-off-by: Randall Spangler <rspangler@chromium.org> Signed-off-by: Simon Glass <sjg@chromium.org> Signed-off-by: Hung-ying Tyan <tyanh@chromium.org> Acked-by: Simon Glass <sjg@chromium.org> Tested-by: Simon Glass <sjg@chromium.org>

cros: add LPC support for cros_ec
This patch adds LPC support for carrying out the cros_ec protocol. Signed-off-by: Randall Spangler <rspangler@chromium.org> Signed-off-by: Simon Glass <sjg@chromium.org> Signed-off-by: Hung-ying Tyan <tyanh@chromium.org> Acked-by: Simon Glass <sjg@chromium.org> Tested-by: Simon Glass <sjg@chromium.org>
Hung-ying Tyan · Tom Rini
1 parent f3424c554c
Showing 2 changed files with 284 additions and 0 deletions Side-by-side Diff
drivers/misc/Makefile
drivers/misc/cros_ec_lpc.c
@@ -29,6 +29,7 @@
 COBJS-$(CONFIG_DS4510)  += ds4510.o
 COBJS-$(CONFIG_CBMEM_CONSOLE) += cbmem_console.o
 COBJS-$(CONFIG_CROS_EC) += cros_ec.o
+COBJS-$(CONFIG_CROS_EC_LPC) += cros_ec_lpc.o
 COBJS-$(CONFIG_CROS_EC_I2C) += cros_ec_i2c.o
 COBJS-$(CONFIG_CROS_EC_SPI) += cros_ec_spi.o
 COBJS-$(CONFIG_FSL_IIM) += fsl_iim.o
+/*
+ * Chromium OS cros_ec driver - LPC interface
+ *
+ * Copyright (c) 2012 The Chromium OS Authors.
+ * See file CREDITS for list of people who contributed to this
+ * project.
+ *
+ * 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
+ */
+
+/*
+ * The Matrix Keyboard Protocol driver handles talking to the keyboard
+ * controller chip. Mostly this is for keyboard functions, but some other
+ * things have slipped in, so we provide generic services to talk to the
+ * KBC.
+ */
+
+#include <common.h>
+#include <command.h>
+#include <cros_ec.h>
+#include <asm/io.h>
+
+#ifdef DEBUG_TRACE
+#define debug_trace(fmt, b...)	debug(fmt, ##b)
+#else
+#define debug_trace(fmt, b...)
+#endif
+
+static int wait_for_sync(struct cros_ec_dev *dev)
+{
+	unsigned long start;
+
+	start = get_timer(0);
+	while (inb(EC_LPC_ADDR_HOST_CMD) & EC_LPC_STATUS_BUSY_MASK) {
+		if (get_timer(start) > 1000) {
+			debug("%s: Timeout waiting for CROS_EC sync\n",
+			      __func__);
+			return -1;
+		}
+	}
+
+	return 0;
+}
+
+/**
+ * Send a command to a LPC CROS_EC device and return the reply.
+ *
+ * The device's internal input/output buffers are used.
+ *
+ * @param dev		CROS_EC device
+ * @param cmd		Command to send (EC_CMD_...)
+ * @param cmd_version	Version of command to send (EC_VER_...)
+ * @param dout          Output data (may be NULL If dout_len=0)
+ * @param dout_len      Size of output data in bytes
+ * @param dinp          Place to put pointer to response data
+ * @param din_len       Maximum size of response in bytes
+ * @return number of bytes in response, or -1 on error
+ */
+static int old_lpc_command(struct cros_ec_dev *dev, uint8_t cmd,
+		     const uint8_t *dout, int dout_len,
+		     uint8_t **dinp, int din_len)
+{
+	int ret, i;
+
+	if (dout_len > EC_OLD_PARAM_SIZE) {
+		debug("%s: Cannot send %d bytes\n", __func__, dout_len);
+		return -1;
+	}
+
+	if (din_len > EC_OLD_PARAM_SIZE) {
+		debug("%s: Cannot receive %d bytes\n", __func__, din_len);
+		return -1;
+	}
+
+	if (wait_for_sync(dev)) {
+		debug("%s: Timeout waiting ready\n", __func__);
+		return -1;
+	}
+
+	debug_trace("cmd: %02x, ", cmd);
+	for (i = 0; i < dout_len; i++) {
+		debug_trace("%02x ", dout[i]);
+		outb(dout[i], EC_LPC_ADDR_OLD_PARAM + i);
+	}
+	outb(cmd, EC_LPC_ADDR_HOST_CMD);
+	debug_trace("\n");
+
+	if (wait_for_sync(dev)) {
+		debug("%s: Timeout waiting ready\n", __func__);
+		return -1;
+	}
+
+	ret = inb(EC_LPC_ADDR_HOST_DATA);
+	if (ret) {
+		debug("%s: CROS_EC result code %d\n", __func__, ret);
+		return -ret;
+	}
+
+	debug_trace("resp: %02x, ", ret);
+	for (i = 0; i < din_len; i++) {
+		dev->din[i] = inb(EC_LPC_ADDR_OLD_PARAM + i);
+		debug_trace("%02x ", dev->din[i]);
+	}
+	debug_trace("\n");
+	*dinp = dev->din;
+
+	return din_len;
+}
+
+int cros_ec_lpc_command(struct cros_ec_dev *dev, uint8_t cmd, int cmd_version,
+		     const uint8_t *dout, int dout_len,
+		     uint8_t **dinp, int din_len)
+{
+	const int cmd_addr = EC_LPC_ADDR_HOST_CMD;
+	const int data_addr = EC_LPC_ADDR_HOST_DATA;
+	const int args_addr = EC_LPC_ADDR_HOST_ARGS;
+	const int param_addr = EC_LPC_ADDR_HOST_PARAM;
+
+	struct ec_lpc_host_args args;
+	uint8_t *d;
+	int csum;
+	int i;
+
+	/* Fall back to old-style command interface if args aren't supported */
+	if (!dev->cmd_version_is_supported)
+		return old_lpc_command(dev, cmd, dout, dout_len, dinp,
+				       din_len);
+
+	if (dout_len > EC_HOST_PARAM_SIZE) {
+		debug("%s: Cannot send %d bytes\n", __func__, dout_len);
+		return -1;
+	}
+
+	/* Fill in args */
+	args.flags = EC_HOST_ARGS_FLAG_FROM_HOST;
+	args.command_version = cmd_version;
+	args.data_size = dout_len;
+
+	/* Calculate checksum */
+	csum = cmd + args.flags + args.command_version + args.data_size;
+	for (i = 0, d = (uint8_t *)dout; i < dout_len; i++, d++)
+		csum += *d;
+
+	args.checksum = (uint8_t)csum;
+
+	if (wait_for_sync(dev)) {
+		debug("%s: Timeout waiting ready\n", __func__);
+		return -1;
+	}
+
+	/* Write args */
+	for (i = 0, d = (uint8_t *)&args; i < sizeof(args); i++, d++)
+		outb(*d, args_addr + i);
+
+	/* Write data, if any */
+	debug_trace("cmd: %02x, ver: %02x", cmd, cmd_version);
+	for (i = 0, d = (uint8_t *)dout; i < dout_len; i++, d++) {
+		outb(*d, param_addr + i);
+		debug_trace("%02x ", *d);
+	}
+
+	outb(cmd, cmd_addr);
+	debug_trace("\n");
+
+	if (wait_for_sync(dev)) {
+		debug("%s: Timeout waiting for response\n", __func__);
+		return -1;
+	}
+
+	/* Check result */
+	i = inb(data_addr);
+	if (i) {
+		debug("%s: CROS_EC result code %d\n", __func__, i);
+		return -i;
+	}
+
+	/* Read back args */
+	for (i = 0, d = (uint8_t *)&args; i < sizeof(args); i++, d++)
+		*d = inb(args_addr + i);
+
+	/*
+	 * If EC didn't modify args flags, then somehow we sent a new-style
+	 * command to an old EC, which means it would have read its params
+	 * from the wrong place.
+	 */
+	if (!(args.flags & EC_HOST_ARGS_FLAG_TO_HOST)) {
+		debug("%s: CROS_EC protocol mismatch\n", __func__);
+		return -EC_RES_INVALID_RESPONSE;
+	}
+
+	if (args.data_size > din_len) {
+		debug("%s: CROS_EC returned too much data %d > %d\n",
+		      __func__, args.data_size, din_len);
+		return -EC_RES_INVALID_RESPONSE;
+	}
+
+	/* Read data, if any */
+	for (i = 0, d = (uint8_t *)dev->din; i < args.data_size; i++, d++) {
+		*d = inb(param_addr + i);
+		debug_trace("%02x ", *d);
+	}
+	debug_trace("\n");
+
+	/* Verify checksum */
+	csum = cmd + args.flags + args.command_version + args.data_size;
+	for (i = 0, d = (uint8_t *)dev->din; i < args.data_size; i++, d++)
+		csum += *d;
+
+	if (args.checksum != (uint8_t)csum) {
+		debug("%s: CROS_EC response has invalid checksum\n", __func__);
+		return -EC_RES_INVALID_CHECKSUM;
+	}
+	*dinp = dev->din;
+
+	/* Return actual amount of data received */
+	return args.data_size;
+}
+
+/**
+ * Initialize LPC protocol.
+ *
+ * @param dev		CROS_EC device
+ * @param blob		Device tree blob
+ * @return 0 if ok, -1 on error
+ */
+int cros_ec_lpc_init(struct cros_ec_dev *dev, const void *blob)
+{
+	int byte, i;
+
+	/* See if we can find an EC at the other end */
+	byte = 0xff;
+	byte &= inb(EC_LPC_ADDR_HOST_CMD);
+	byte &= inb(EC_LPC_ADDR_HOST_DATA);
+	for (i = 0; i < EC_HOST_PARAM_SIZE && (byte == 0xff); i++)
+		byte &= inb(EC_LPC_ADDR_HOST_PARAM + i);
+	if (byte == 0xff) {
+		debug("%s: CROS_EC device not found on LPC bus\n",
+			__func__);
+		return -1;
+	}
+
+	return 0;
+}
+
+/*
+ * Test if LPC command args are supported.
+ *
+ * The cheapest way to do this is by looking for the memory-mapped
+ * flag.  This is faster than sending a new-style 'hello' command and
+ * seeing whether the EC sets the EC_HOST_ARGS_FLAG_FROM_HOST flag
+ * in args when it responds.
+ */
+int cros_ec_lpc_check_version(struct cros_ec_dev *dev)
+{
+	if (inb(EC_LPC_ADDR_MEMMAP + EC_MEMMAP_ID) == 'E' &&
+			inb(EC_LPC_ADDR_MEMMAP + EC_MEMMAP_ID + 1)
+				== 'C' &&
+			(inb(EC_LPC_ADDR_MEMMAP +
+				EC_MEMMAP_HOST_CMD_FLAGS) &
+				EC_HOST_CMD_FLAG_LPC_ARGS_SUPPORTED)) {
+		dev->cmd_version_is_supported = 1;
+	} else {
+		/* We are going to use the old IO ports */
+		dev->cmd_version_is_supported = 0;
+	}
+	debug("lpc: version %s\n", dev->cmd_version_is_supported ?
+			"new" : "old");
+
+	return 0;
+}
...	...	@@ -29,6 +29,7 @@
29	29	COBJS-$(CONFIG_DS4510) += ds4510.o
30	30	COBJS-$(CONFIG_CBMEM_CONSOLE) += cbmem_console.o
31	31	COBJS-$(CONFIG_CROS_EC) += cros_ec.o
	32	+COBJS-$(CONFIG_CROS_EC_LPC) += cros_ec_lpc.o
32	33	COBJS-$(CONFIG_CROS_EC_I2C) += cros_ec_i2c.o
33	34	COBJS-$(CONFIG_CROS_EC_SPI) += cros_ec_spi.o
34	35	COBJS-$(CONFIG_FSL_IIM) += fsl_iim.o
	1	+/*
	2	+ * Chromium OS cros_ec driver - LPC interface
	3	+ *
	4	+ * Copyright (c) 2012 The Chromium OS Authors.
	5	+ * See file CREDITS for list of people who contributed to this
	6	+ * project.
	7	+ *
	8	+ * This program is free software; you can redistribute it and/or
	9	+ * modify it under the terms of the GNU General Public License as
	10	+ * published by the Free Software Foundation; either version 2 of
	11	+ * the License, or (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,
	21	+ * MA 02111-1307 USA
	22	+ */
	23	+
	24	+/*
	25	+ * The Matrix Keyboard Protocol driver handles talking to the keyboard
	26	+ * controller chip. Mostly this is for keyboard functions, but some other
	27	+ * things have slipped in, so we provide generic services to talk to the
	28	+ * KBC.
	29	+ */
	30	+
	31	+#include <common.h>
	32	+#include <command.h>
	33	+#include <cros_ec.h>
	34	+#include <asm/io.h>
	35	+
	36	+#ifdef DEBUG_TRACE
	37	+#define debug_trace(fmt, b...) debug(fmt, ##b)
	38	+#else
	39	+#define debug_trace(fmt, b...)
	40	+#endif
	41	+
	42	+static int wait_for_sync(struct cros_ec_dev *dev)
	43	+{
	44	+ unsigned long start;
	45	+
	46	+ start = get_timer(0);
	47	+ while (inb(EC_LPC_ADDR_HOST_CMD) & EC_LPC_STATUS_BUSY_MASK) {
	48	+ if (get_timer(start) > 1000) {
	49	+ debug("%s: Timeout waiting for CROS_EC sync\n",
	50	+ __func__);
	51	+ return -1;
	52	+ }
	53	+ }
	54	+
	55	+ return 0;
	56	+}
	57	+
	58	+/**
	59	+ * Send a command to a LPC CROS_EC device and return the reply.
	60	+ *
	61	+ * The device's internal input/output buffers are used.
	62	+ *
	63	+ * @param dev CROS_EC device
	64	+ * @param cmd Command to send (EC_CMD_...)
	65	+ * @param cmd_version Version of command to send (EC_VER_...)
	66	+ * @param dout Output data (may be NULL If dout_len=0)
	67	+ * @param dout_len Size of output data in bytes
	68	+ * @param dinp Place to put pointer to response data
	69	+ * @param din_len Maximum size of response in bytes
	70	+ * @return number of bytes in response, or -1 on error
	71	+ */
	72	+static int old_lpc_command(struct cros_ec_dev *dev, uint8_t cmd,
	73	+ const uint8_t *dout, int dout_len,
	74	+ uint8_t **dinp, int din_len)
	75	+{
	76	+ int ret, i;
	77	+
	78	+ if (dout_len > EC_OLD_PARAM_SIZE) {
	79	+ debug("%s: Cannot send %d bytes\n", __func__, dout_len);
	80	+ return -1;
	81	+ }
	82	+
	83	+ if (din_len > EC_OLD_PARAM_SIZE) {
	84	+ debug("%s: Cannot receive %d bytes\n", __func__, din_len);
	85	+ return -1;
	86	+ }
	87	+
	88	+ if (wait_for_sync(dev)) {
	89	+ debug("%s: Timeout waiting ready\n", __func__);
	90	+ return -1;
	91	+ }
	92	+
	93	+ debug_trace("cmd: %02x, ", cmd);
	94	+ for (i = 0; i < dout_len; i++) {
	95	+ debug_trace("%02x ", dout[i]);
	96	+ outb(dout[i], EC_LPC_ADDR_OLD_PARAM + i);
	97	+ }
	98	+ outb(cmd, EC_LPC_ADDR_HOST_CMD);
	99	+ debug_trace("\n");
	100	+
	101	+ if (wait_for_sync(dev)) {
	102	+ debug("%s: Timeout waiting ready\n", __func__);
	103	+ return -1;
	104	+ }
	105	+
	106	+ ret = inb(EC_LPC_ADDR_HOST_DATA);
	107	+ if (ret) {
	108	+ debug("%s: CROS_EC result code %d\n", __func__, ret);
	109	+ return -ret;
	110	+ }
	111	+
	112	+ debug_trace("resp: %02x, ", ret);
	113	+ for (i = 0; i < din_len; i++) {
	114	+ dev->din[i] = inb(EC_LPC_ADDR_OLD_PARAM + i);
	115	+ debug_trace("%02x ", dev->din[i]);
	116	+ }
	117	+ debug_trace("\n");
	118	+ *dinp = dev->din;
	119	+
	120	+ return din_len;
	121	+}
	122	+
	123	+int cros_ec_lpc_command(struct cros_ec_dev *dev, uint8_t cmd, int cmd_version,
	124	+ const uint8_t *dout, int dout_len,
	125	+ uint8_t **dinp, int din_len)
	126	+{
	127	+ const int cmd_addr = EC_LPC_ADDR_HOST_CMD;
	128	+ const int data_addr = EC_LPC_ADDR_HOST_DATA;
	129	+ const int args_addr = EC_LPC_ADDR_HOST_ARGS;
	130	+ const int param_addr = EC_LPC_ADDR_HOST_PARAM;
	131	+
	132	+ struct ec_lpc_host_args args;
	133	+ uint8_t *d;
	134	+ int csum;
	135	+ int i;
	136	+
	137	+ /* Fall back to old-style command interface if args aren't supported */
	138	+ if (!dev->cmd_version_is_supported)
	139	+ return old_lpc_command(dev, cmd, dout, dout_len, dinp,
	140	+ din_len);
	141	+
	142	+ if (dout_len > EC_HOST_PARAM_SIZE) {
	143	+ debug("%s: Cannot send %d bytes\n", __func__, dout_len);
	144	+ return -1;
	145	+ }
	146	+
	147	+ /* Fill in args */
	148	+ args.flags = EC_HOST_ARGS_FLAG_FROM_HOST;
	149	+ args.command_version = cmd_version;
	150	+ args.data_size = dout_len;
	151	+
	152	+ /* Calculate checksum */
	153	+ csum = cmd + args.flags + args.command_version + args.data_size;
	154	+ for (i = 0, d = (uint8_t *)dout; i < dout_len; i++, d++)
	155	+ csum += *d;
	156	+
	157	+ args.checksum = (uint8_t)csum;
	158	+
	159	+ if (wait_for_sync(dev)) {
	160	+ debug("%s: Timeout waiting ready\n", __func__);
	161	+ return -1;
	162	+ }
	163	+
	164	+ /* Write args */
	165	+ for (i = 0, d = (uint8_t *)&args; i < sizeof(args); i++, d++)
	166	+ outb(*d, args_addr + i);
	167	+
	168	+ /* Write data, if any */
	169	+ debug_trace("cmd: %02x, ver: %02x", cmd, cmd_version);
	170	+ for (i = 0, d = (uint8_t *)dout; i < dout_len; i++, d++) {
	171	+ outb(*d, param_addr + i);
	172	+ debug_trace("%02x ", *d);
	173	+ }
	174	+
	175	+ outb(cmd, cmd_addr);
	176	+ debug_trace("\n");
	177	+
	178	+ if (wait_for_sync(dev)) {
	179	+ debug("%s: Timeout waiting for response\n", __func__);
	180	+ return -1;
	181	+ }
	182	+
	183	+ /* Check result */
	184	+ i = inb(data_addr);
	185	+ if (i) {
	186	+ debug("%s: CROS_EC result code %d\n", __func__, i);
	187	+ return -i;
	188	+ }
	189	+
	190	+ /* Read back args */
	191	+ for (i = 0, d = (uint8_t *)&args; i < sizeof(args); i++, d++)
	192	+ *d = inb(args_addr + i);
	193	+
	194	+ /*
	195	+ * If EC didn't modify args flags, then somehow we sent a new-style
	196	+ * command to an old EC, which means it would have read its params
	197	+ * from the wrong place.
	198	+ */
	199	+ if (!(args.flags & EC_HOST_ARGS_FLAG_TO_HOST)) {
	200	+ debug("%s: CROS_EC protocol mismatch\n", __func__);
	201	+ return -EC_RES_INVALID_RESPONSE;
	202	+ }
	203	+
	204	+ if (args.data_size > din_len) {
	205	+ debug("%s: CROS_EC returned too much data %d > %d\n",
	206	+ __func__, args.data_size, din_len);
	207	+ return -EC_RES_INVALID_RESPONSE;
	208	+ }
	209	+
	210	+ /* Read data, if any */
	211	+ for (i = 0, d = (uint8_t *)dev->din; i < args.data_size; i++, d++) {
	212	+ *d = inb(param_addr + i);
	213	+ debug_trace("%02x ", *d);
	214	+ }
	215	+ debug_trace("\n");
	216	+
	217	+ /* Verify checksum */
	218	+ csum = cmd + args.flags + args.command_version + args.data_size;
	219	+ for (i = 0, d = (uint8_t *)dev->din; i < args.data_size; i++, d++)
	220	+ csum += *d;
	221	+
	222	+ if (args.checksum != (uint8_t)csum) {
	223	+ debug("%s: CROS_EC response has invalid checksum\n", __func__);
	224	+ return -EC_RES_INVALID_CHECKSUM;
	225	+ }
	226	+ *dinp = dev->din;
	227	+
	228	+ /* Return actual amount of data received */
	229	+ return args.data_size;
	230	+}
	231	+
	232	+/**
	233	+ * Initialize LPC protocol.
	234	+ *
	235	+ * @param dev CROS_EC device
	236	+ * @param blob Device tree blob
	237	+ * @return 0 if ok, -1 on error
	238	+ */
	239	+int cros_ec_lpc_init(struct cros_ec_dev dev, const void blob)
	240	+{
	241	+ int byte, i;
	242	+
	243	+ /* See if we can find an EC at the other end */
	244	+ byte = 0xff;
	245	+ byte &= inb(EC_LPC_ADDR_HOST_CMD);
	246	+ byte &= inb(EC_LPC_ADDR_HOST_DATA);
	247	+ for (i = 0; i < EC_HOST_PARAM_SIZE && (byte == 0xff); i++)
	248	+ byte &= inb(EC_LPC_ADDR_HOST_PARAM + i);
	249	+ if (byte == 0xff) {
	250	+ debug("%s: CROS_EC device not found on LPC bus\n",
	251	+ __func__);
	252	+ return -1;
	253	+ }
	254	+
	255	+ return 0;
	256	+}
	257	+
	258	+/*
	259	+ * Test if LPC command args are supported.
	260	+ *
	261	+ * The cheapest way to do this is by looking for the memory-mapped
	262	+ * flag. This is faster than sending a new-style 'hello' command and
	263	+ * seeing whether the EC sets the EC_HOST_ARGS_FLAG_FROM_HOST flag
	264	+ * in args when it responds.
	265	+ */
	266	+int cros_ec_lpc_check_version(struct cros_ec_dev *dev)
	267	+{
	268	+ if (inb(EC_LPC_ADDR_MEMMAP + EC_MEMMAP_ID) == 'E' &&
	269	+ inb(EC_LPC_ADDR_MEMMAP + EC_MEMMAP_ID + 1)
	270	+ == 'C' &&
	271	+ (inb(EC_LPC_ADDR_MEMMAP +
	272	+ EC_MEMMAP_HOST_CMD_FLAGS) &
	273	+ EC_HOST_CMD_FLAG_LPC_ARGS_SUPPORTED)) {
	274	+ dev->cmd_version_is_supported = 1;
	275	+ } else {
	276	+ /* We are going to use the old IO ports */
	277	+ dev->cmd_version_is_supported = 0;
	278	+ }
	279	+ debug("lpc: version %s\n", dev->cmd_version_is_supported ?
	280	+ "new" : "old");
	281	+
	282	+ return 0;
	283	+}