1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
|
// SPDX-License-Identifier: GPL-2.0+
/*
* Chromium OS cros_ec driver - I2C interface
*
* Copyright (c) 2012 The Chromium OS Authors.
*/
/*
* 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 <dm.h>
#include <i2c.h>
#include <cros_ec.h>
#ifdef DEBUG_TRACE
#define debug_trace(fmt, b...) debug(fmt, #b)
#else
#define debug_trace(fmt, b...)
#endif
/**
* Request format for protocol v3
* byte 0 0xda (EC_COMMAND_PROTOCOL_3)
* byte 1-8 struct ec_host_request
* byte 10- response data
*/
struct ec_host_request_i2c {
/* Always 0xda to backward compatible with v2 struct */
uint8_t command_protocol;
struct ec_host_request ec_request;
} __packed;
/*
* Response format for protocol v3
* byte 0 result code
* byte 1 packet_length
* byte 2-9 struct ec_host_response
* byte 10- response data
*/
struct ec_host_response_i2c {
uint8_t result;
uint8_t packet_length;
struct ec_host_response ec_response;
} __packed;
static int cros_ec_i2c_packet(struct udevice *udev, int out_bytes, int in_bytes)
{
struct cros_ec_dev *dev = dev_get_uclass_priv(udev);
struct dm_i2c_chip *chip = dev_get_parent_platdata(udev);
struct ec_host_request_i2c *ec_request_i2c =
(struct ec_host_request_i2c *)dev->dout;
struct ec_host_response_i2c *ec_response_i2c =
(struct ec_host_response_i2c *)dev->din;
struct i2c_msg i2c_msg[2];
int ret;
i2c_msg[0].addr = chip->chip_addr;
i2c_msg[0].flags = 0;
i2c_msg[1].addr = chip->chip_addr;
i2c_msg[1].flags = I2C_M_RD;
/* one extra byte, to indicate v3 */
i2c_msg[0].len = out_bytes + 1;
i2c_msg[0].buf = dev->dout;
/* stitch on EC_COMMAND_PROTOCOL_3 */
memmove(&ec_request_i2c->ec_request, dev->dout, out_bytes);
ec_request_i2c->command_protocol = EC_COMMAND_PROTOCOL_3;
/* two extra bytes for v3 */
i2c_msg[1].len = in_bytes + 2;
i2c_msg[1].buf = dev->din;
ret = dm_i2c_xfer(udev, &i2c_msg[0], 2);
if (ret) {
printf("%s: Could not execute transfer: %d\n", __func__, ret);
return ret;
}
/* When we send a v3 request to v2 ec, ec won't recognize the 0xda
* (EC_COMMAND_PROTOCOL_3) and will return with status
* EC_RES_INVALID_COMMAND with zero data length
*
* In case of invalid command for v3 protocol the data length
* will be at least sizeof(struct ec_host_response)
*/
if (ec_response_i2c->result == EC_RES_INVALID_COMMAND &&
ec_response_i2c->packet_length == 0)
return -EPROTONOSUPPORT;
if (ec_response_i2c->packet_length < sizeof(struct ec_host_response)) {
printf("%s: response of %u bytes too short; not a full hdr\n",
__func__, ec_response_i2c->packet_length);
return -EBADMSG;
}
/* drop result and packet_len */
memmove(dev->din, &ec_response_i2c->ec_response, in_bytes);
return in_bytes;
}
static int cros_ec_i2c_command(struct udevice *udev, uint8_t cmd,
int cmd_version, const uint8_t *dout,
int dout_len, uint8_t **dinp, int din_len)
{
struct cros_ec_dev *dev = dev_get_uclass_priv(udev);
struct dm_i2c_chip *chip = dev_get_parent_platdata(udev);
struct i2c_msg i2c_msg[2];
/* version8, cmd8, arglen8, out8[dout_len], csum8 */
int out_bytes = dout_len + 4;
/* response8, arglen8, in8[din_len], checksum8 */
int in_bytes = din_len + 3;
uint8_t *ptr;
/* Receive input data, so that args will be dword aligned */
uint8_t *in_ptr;
int len, csum, ret;
/*
* Sanity-check I/O sizes given transaction overhead in internal
* buffers.
*/
if (out_bytes > sizeof(dev->dout)) {
debug("%s: Cannot send %d bytes\n", __func__, dout_len);
return -1;
}
if (in_bytes > sizeof(dev->din)) {
debug("%s: Cannot receive %d bytes\n", __func__, din_len);
return -1;
}
assert(dout_len >= 0);
assert(dinp);
i2c_msg[0].addr = chip->chip_addr;
i2c_msg[0].len = out_bytes;
i2c_msg[0].buf = dev->dout;
i2c_msg[0].flags = 0;
/*
* Copy command and data into output buffer so we can do a single I2C
* burst transaction.
*/
ptr = dev->dout;
/*
* in_ptr starts of pointing to a dword-aligned input data buffer.
* We decrement it back by the number of header bytes we expect to
* receive, so that the first parameter of the resulting input data
* will be dword aligned.
*/
in_ptr = dev->din + sizeof(int64_t);
if (dev->protocol_version != 2) {
/* Something we don't support */
debug("%s: Protocol version %d unsupported\n",
__func__, dev->protocol_version);
return -1;
}
*ptr++ = EC_CMD_VERSION0 + cmd_version;
*ptr++ = cmd;
*ptr++ = dout_len;
in_ptr -= 2; /* Expect status, length bytes */
memcpy(ptr, dout, dout_len);
ptr += dout_len;
*ptr++ = (uint8_t)
cros_ec_calc_checksum(dev->dout, dout_len + 3);
i2c_msg[1].addr = chip->chip_addr;
i2c_msg[1].len = in_bytes;
i2c_msg[1].buf = in_ptr;
i2c_msg[1].flags = I2C_M_RD;
/* Send output data */
cros_ec_dump_data("out", -1, dev->dout, out_bytes);
ret = dm_i2c_xfer(udev, &i2c_msg[0], 2);
if (ret) {
debug("%s: Could not execute transfer to %s\n", __func__,
udev->name);
ret = -1;
}
if (*in_ptr != EC_RES_SUCCESS) {
debug("%s: Received bad result code %d\n", __func__, *in_ptr);
return -(int)*in_ptr;
}
len = in_ptr[1];
if (len + 3 > sizeof(dev->din)) {
debug("%s: Received length %#02x too large\n",
__func__, len);
return -1;
}
csum = cros_ec_calc_checksum(in_ptr, 2 + len);
if (csum != in_ptr[2 + len]) {
debug("%s: Invalid checksum rx %#02x, calced %#02x\n",
__func__, in_ptr[2 + din_len], csum);
return -1;
}
din_len = min(din_len, len);
cros_ec_dump_data("in", -1, in_ptr, din_len + 3);
/* Return pointer to dword-aligned input data, if any */
*dinp = dev->din + sizeof(int64_t);
return din_len;
}
static int cros_ec_probe(struct udevice *dev)
{
return cros_ec_register(dev);
}
static struct dm_cros_ec_ops cros_ec_ops = {
.command = cros_ec_i2c_command,
.packet = cros_ec_i2c_packet,
};
static const struct udevice_id cros_ec_ids[] = {
{ .compatible = "google,cros-ec-i2c" },
{ }
};
U_BOOT_DRIVER(cros_ec_i2c) = {
.name = "cros_ec_i2c",
.id = UCLASS_CROS_EC,
.of_match = cros_ec_ids,
.probe = cros_ec_probe,
.ops = &cros_ec_ops,
};
|
