xref: /openbmc/u-boot/drivers/misc/cros_ec_i2c.c (revision 83bf0057)
1 /*
2  * Chromium OS cros_ec driver - I2C interface
3  *
4  * Copyright (c) 2012 The Chromium OS Authors.
5  *
6  * SPDX-License-Identifier:	GPL-2.0+
7  */
8 
9 /*
10  * The Matrix Keyboard Protocol driver handles talking to the keyboard
11  * controller chip. Mostly this is for keyboard functions, but some other
12  * things have slipped in, so we provide generic services to talk to the
13  * KBC.
14  */
15 
16 #include <common.h>
17 #include <dm.h>
18 #include <i2c.h>
19 #include <cros_ec.h>
20 
21 #ifdef DEBUG_TRACE
22 #define debug_trace(fmt, b...)	debug(fmt, #b)
23 #else
24 #define debug_trace(fmt, b...)
25 #endif
26 
27 static int cros_ec_i2c_command(struct udevice *udev, uint8_t cmd,
28 			       int cmd_version, const uint8_t *dout,
29 			       int dout_len, uint8_t **dinp, int din_len)
30 {
31 	struct cros_ec_dev *dev = dev_get_uclass_priv(udev);
32 	/* version8, cmd8, arglen8, out8[dout_len], csum8 */
33 	int out_bytes = dout_len + 4;
34 	/* response8, arglen8, in8[din_len], checksum8 */
35 	int in_bytes = din_len + 3;
36 	uint8_t *ptr;
37 	/* Receive input data, so that args will be dword aligned */
38 	uint8_t *in_ptr;
39 	int len, csum, ret;
40 
41 	/*
42 	 * Sanity-check I/O sizes given transaction overhead in internal
43 	 * buffers.
44 	 */
45 	if (out_bytes > sizeof(dev->dout)) {
46 		debug("%s: Cannot send %d bytes\n", __func__, dout_len);
47 		return -1;
48 	}
49 	if (in_bytes > sizeof(dev->din)) {
50 		debug("%s: Cannot receive %d bytes\n", __func__, din_len);
51 		return -1;
52 	}
53 	assert(dout_len >= 0);
54 	assert(dinp);
55 
56 	/*
57 	 * Copy command and data into output buffer so we can do a single I2C
58 	 * burst transaction.
59 	 */
60 	ptr = dev->dout;
61 
62 	/*
63 	 * in_ptr starts of pointing to a dword-aligned input data buffer.
64 	 * We decrement it back by the number of header bytes we expect to
65 	 * receive, so that the first parameter of the resulting input data
66 	 * will be dword aligned.
67 	 */
68 	in_ptr = dev->din + sizeof(int64_t);
69 
70 	if (dev->protocol_version != 2) {
71 		/* Something we don't support */
72 		debug("%s: Protocol version %d unsupported\n",
73 		      __func__, dev->protocol_version);
74 		return -1;
75 	}
76 
77 	*ptr++ = EC_CMD_VERSION0 + cmd_version;
78 	*ptr++ = cmd;
79 	*ptr++ = dout_len;
80 	in_ptr -= 2;	/* Expect status, length bytes */
81 
82 	memcpy(ptr, dout, dout_len);
83 	ptr += dout_len;
84 
85 	*ptr++ = (uint8_t)
86 		cros_ec_calc_checksum(dev->dout, dout_len + 3);
87 
88 	/* Send output data */
89 	cros_ec_dump_data("out", -1, dev->dout, out_bytes);
90 	ret = dm_i2c_write(udev, 0, dev->dout, out_bytes);
91 	if (ret) {
92 		debug("%s: Cannot complete I2C write to %s\n", __func__,
93 		      udev->name);
94 		ret = -1;
95 	}
96 
97 	if (!ret) {
98 		ret = dm_i2c_read(udev, 0, in_ptr, in_bytes);
99 		if (ret) {
100 			debug("%s: Cannot complete I2C read from %s\n",
101 			      __func__, udev->name);
102 			ret = -1;
103 		}
104 	}
105 
106 	if (*in_ptr != EC_RES_SUCCESS) {
107 		debug("%s: Received bad result code %d\n", __func__, *in_ptr);
108 		return -(int)*in_ptr;
109 	}
110 
111 	len = in_ptr[1];
112 	if (len + 3 > sizeof(dev->din)) {
113 		debug("%s: Received length %#02x too large\n",
114 		      __func__, len);
115 		return -1;
116 	}
117 	csum = cros_ec_calc_checksum(in_ptr, 2 + len);
118 	if (csum != in_ptr[2 + len]) {
119 		debug("%s: Invalid checksum rx %#02x, calced %#02x\n",
120 		      __func__, in_ptr[2 + din_len], csum);
121 		return -1;
122 	}
123 	din_len = min(din_len, len);
124 	cros_ec_dump_data("in", -1, in_ptr, din_len + 3);
125 
126 	/* Return pointer to dword-aligned input data, if any */
127 	*dinp = dev->din + sizeof(int64_t);
128 
129 	return din_len;
130 }
131 
132 static int cros_ec_probe(struct udevice *dev)
133 {
134 	return cros_ec_register(dev);
135 }
136 
137 static struct dm_cros_ec_ops cros_ec_ops = {
138 	.command = cros_ec_i2c_command,
139 };
140 
141 static const struct udevice_id cros_ec_ids[] = {
142 	{ .compatible = "google,cros-ec-i2c" },
143 	{ }
144 };
145 
146 U_BOOT_DRIVER(cros_ec_i2c) = {
147 	.name		= "cros_ec_i2c",
148 	.id		= UCLASS_CROS_EC,
149 	.of_match	= cros_ec_ids,
150 	.probe		= cros_ec_probe,
151 	.ops		= &cros_ec_ops,
152 };
153