2 * Chromium OS cros_ec driver - I2C interface
4 * Copyright (c) 2012 The Chromium OS Authors.
6 * SPDX-License-Identifier: GPL-2.0+
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
22 #define debug_trace(fmt, b...) debug(fmt, #b)
24 #define debug_trace(fmt, b...)
28 * Request format for protocol v3
29 * byte 0 0xda (EC_COMMAND_PROTOCOL_3)
30 * byte 1-8 struct ec_host_request
31 * byte 10- response data
33 struct ec_host_request_i2c
{
34 /* Always 0xda to backward compatible with v2 struct */
35 uint8_t command_protocol
;
36 struct ec_host_request ec_request
;
40 * Response format for protocol v3
42 * byte 1 packet_length
43 * byte 2-9 struct ec_host_response
44 * byte 10- response data
46 struct ec_host_response_i2c
{
48 uint8_t packet_length
;
49 struct ec_host_response ec_response
;
52 static int cros_ec_i2c_packet(struct udevice
*udev
, int out_bytes
, int in_bytes
)
54 struct cros_ec_dev
*dev
= dev_get_uclass_priv(udev
);
55 struct dm_i2c_chip
*chip
= dev_get_parent_platdata(udev
);
56 struct ec_host_request_i2c
*ec_request_i2c
=
57 (struct ec_host_request_i2c
*)dev
->dout
;
58 struct ec_host_response_i2c
*ec_response_i2c
=
59 (struct ec_host_response_i2c
*)dev
->din
;
60 struct i2c_msg i2c_msg
[2];
63 i2c_msg
[0].addr
= chip
->chip_addr
;
65 i2c_msg
[1].addr
= chip
->chip_addr
;
66 i2c_msg
[1].flags
= I2C_M_RD
;
68 /* one extra byte, to indicate v3 */
69 i2c_msg
[0].len
= out_bytes
+ 1;
70 i2c_msg
[0].buf
= dev
->dout
;
72 /* stitch on EC_COMMAND_PROTOCOL_3 */
73 memmove(&ec_request_i2c
->ec_request
, dev
->dout
, out_bytes
);
74 ec_request_i2c
->command_protocol
= EC_COMMAND_PROTOCOL_3
;
76 /* two extra bytes for v3 */
77 i2c_msg
[1].len
= in_bytes
+ 2;
78 i2c_msg
[1].buf
= dev
->din
;
80 ret
= dm_i2c_xfer(udev
, &i2c_msg
[0], 2);
82 printf("%s: Could not execute transfer: %d\n", __func__
, ret
);
86 /* When we send a v3 request to v2 ec, ec won't recognize the 0xda
87 * (EC_COMMAND_PROTOCOL_3) and will return with status
88 * EC_RES_INVALID_COMMAND with zero data length
90 * In case of invalid command for v3 protocol the data length
91 * will be at least sizeof(struct ec_host_response)
93 if (ec_response_i2c
->result
== EC_RES_INVALID_COMMAND
&&
94 ec_response_i2c
->packet_length
== 0)
95 return -EPROTONOSUPPORT
;
97 if (ec_response_i2c
->packet_length
< sizeof(struct ec_host_response
)) {
98 printf("%s: response of %u bytes too short; not a full hdr\n",
99 __func__
, ec_response_i2c
->packet_length
);
104 /* drop result and packet_len */
105 memmove(dev
->din
, &ec_response_i2c
->ec_response
, in_bytes
);
110 static int cros_ec_i2c_command(struct udevice
*udev
, uint8_t cmd
,
111 int cmd_version
, const uint8_t *dout
,
112 int dout_len
, uint8_t **dinp
, int din_len
)
114 struct cros_ec_dev
*dev
= dev_get_uclass_priv(udev
);
115 struct dm_i2c_chip
*chip
= dev_get_parent_platdata(udev
);
116 struct i2c_msg i2c_msg
[2];
117 /* version8, cmd8, arglen8, out8[dout_len], csum8 */
118 int out_bytes
= dout_len
+ 4;
119 /* response8, arglen8, in8[din_len], checksum8 */
120 int in_bytes
= din_len
+ 3;
122 /* Receive input data, so that args will be dword aligned */
127 * Sanity-check I/O sizes given transaction overhead in internal
130 if (out_bytes
> sizeof(dev
->dout
)) {
131 debug("%s: Cannot send %d bytes\n", __func__
, dout_len
);
134 if (in_bytes
> sizeof(dev
->din
)) {
135 debug("%s: Cannot receive %d bytes\n", __func__
, din_len
);
138 assert(dout_len
>= 0);
141 i2c_msg
[0].addr
= chip
->chip_addr
;
142 i2c_msg
[0].len
= out_bytes
;
143 i2c_msg
[0].buf
= dev
->dout
;
144 i2c_msg
[0].flags
= 0;
147 * Copy command and data into output buffer so we can do a single I2C
153 * in_ptr starts of pointing to a dword-aligned input data buffer.
154 * We decrement it back by the number of header bytes we expect to
155 * receive, so that the first parameter of the resulting input data
156 * will be dword aligned.
158 in_ptr
= dev
->din
+ sizeof(int64_t);
160 if (dev
->protocol_version
!= 2) {
161 /* Something we don't support */
162 debug("%s: Protocol version %d unsupported\n",
163 __func__
, dev
->protocol_version
);
167 *ptr
++ = EC_CMD_VERSION0
+ cmd_version
;
170 in_ptr
-= 2; /* Expect status, length bytes */
172 memcpy(ptr
, dout
, dout_len
);
176 cros_ec_calc_checksum(dev
->dout
, dout_len
+ 3);
178 i2c_msg
[1].addr
= chip
->chip_addr
;
179 i2c_msg
[1].len
= in_bytes
;
180 i2c_msg
[1].buf
= in_ptr
;
181 i2c_msg
[1].flags
= I2C_M_RD
;
183 /* Send output data */
184 cros_ec_dump_data("out", -1, dev
->dout
, out_bytes
);
186 ret
= dm_i2c_xfer(udev
, &i2c_msg
[0], 2);
188 debug("%s: Could not execute transfer to %s\n", __func__
,
193 if (*in_ptr
!= EC_RES_SUCCESS
) {
194 debug("%s: Received bad result code %d\n", __func__
, *in_ptr
);
195 return -(int)*in_ptr
;
199 if (len
+ 3 > sizeof(dev
->din
)) {
200 debug("%s: Received length %#02x too large\n",
204 csum
= cros_ec_calc_checksum(in_ptr
, 2 + len
);
205 if (csum
!= in_ptr
[2 + len
]) {
206 debug("%s: Invalid checksum rx %#02x, calced %#02x\n",
207 __func__
, in_ptr
[2 + din_len
], csum
);
210 din_len
= min(din_len
, len
);
211 cros_ec_dump_data("in", -1, in_ptr
, din_len
+ 3);
213 /* Return pointer to dword-aligned input data, if any */
214 *dinp
= dev
->din
+ sizeof(int64_t);
219 static int cros_ec_probe(struct udevice
*dev
)
221 return cros_ec_register(dev
);
224 static struct dm_cros_ec_ops cros_ec_ops
= {
225 .command
= cros_ec_i2c_command
,
226 .packet
= cros_ec_i2c_packet
,
229 static const struct udevice_id cros_ec_ids
[] = {
230 { .compatible
= "google,cros-ec-i2c" },
234 U_BOOT_DRIVER(cros_ec_i2c
) = {
235 .name
= "cros_ec_i2c",
236 .id
= UCLASS_CROS_EC
,
237 .of_match
= cros_ec_ids
,
238 .probe
= cros_ec_probe
,