1 | // SPDX-License-Identifier: GPL-2.0 |
2 | // I2C interface for ChromeOS Embedded Controller |
3 | // |
4 | // Copyright (C) 2012 Google, Inc |
5 | |
6 | #include <linux/acpi.h> |
7 | #include <linux/delay.h> |
8 | #include <linux/kernel.h> |
9 | #include <linux/module.h> |
10 | #include <linux/i2c.h> |
11 | #include <linux/interrupt.h> |
12 | #include <linux/platform_data/cros_ec_commands.h> |
13 | #include <linux/platform_data/cros_ec_proto.h> |
14 | #include <linux/platform_device.h> |
15 | #include <linux/slab.h> |
16 | |
17 | #include "cros_ec.h" |
18 | |
19 | /* |
20 | * Request format for protocol v3 |
21 | * byte 0 0xda (EC_COMMAND_PROTOCOL_3) |
22 | * byte 1-8 struct ec_host_request |
23 | * byte 10- response data |
24 | */ |
25 | struct ec_host_request_i2c { |
26 | /* Always 0xda to backward compatible with v2 struct */ |
27 | uint8_t command_protocol; |
28 | struct ec_host_request ec_request; |
29 | } __packed; |
30 | |
31 | |
32 | /* |
33 | * Response format for protocol v3 |
34 | * byte 0 result code |
35 | * byte 1 packet_length |
36 | * byte 2-9 struct ec_host_response |
37 | * byte 10- response data |
38 | */ |
39 | struct ec_host_response_i2c { |
40 | uint8_t result; |
41 | uint8_t packet_length; |
42 | struct ec_host_response ec_response; |
43 | } __packed; |
44 | |
45 | static inline struct cros_ec_device *to_ec_dev(struct device *dev) |
46 | { |
47 | struct i2c_client *client = to_i2c_client(dev); |
48 | |
49 | return i2c_get_clientdata(client); |
50 | } |
51 | |
52 | static int cros_ec_pkt_xfer_i2c(struct cros_ec_device *ec_dev, |
53 | struct cros_ec_command *msg) |
54 | { |
55 | struct i2c_client *client = ec_dev->priv; |
56 | int ret = -ENOMEM; |
57 | int i; |
58 | int packet_len; |
59 | u8 *out_buf = NULL; |
60 | u8 *in_buf = NULL; |
61 | u8 sum; |
62 | struct i2c_msg i2c_msg[2]; |
63 | struct ec_host_response *ec_response; |
64 | struct ec_host_request_i2c *ec_request_i2c; |
65 | struct ec_host_response_i2c *ec_response_i2c; |
66 | int = sizeof(struct ec_host_request_i2c); |
67 | int = sizeof(struct ec_host_response_i2c); |
68 | |
69 | i2c_msg[0].addr = client->addr; |
70 | i2c_msg[0].flags = 0; |
71 | i2c_msg[1].addr = client->addr; |
72 | i2c_msg[1].flags = I2C_M_RD; |
73 | |
74 | packet_len = msg->insize + response_header_size; |
75 | if (packet_len > ec_dev->din_size) { |
76 | ret = -EINVAL; |
77 | goto done; |
78 | } |
79 | in_buf = ec_dev->din; |
80 | i2c_msg[1].len = packet_len; |
81 | i2c_msg[1].buf = (char *) in_buf; |
82 | |
83 | packet_len = msg->outsize + request_header_size; |
84 | if (packet_len > ec_dev->dout_size) { |
85 | ret = -EINVAL; |
86 | goto done; |
87 | } |
88 | out_buf = ec_dev->dout; |
89 | i2c_msg[0].len = packet_len; |
90 | i2c_msg[0].buf = (char *) out_buf; |
91 | |
92 | /* create request data */ |
93 | ec_request_i2c = (struct ec_host_request_i2c *) out_buf; |
94 | ec_request_i2c->command_protocol = EC_COMMAND_PROTOCOL_3; |
95 | |
96 | ec_dev->dout++; |
97 | ret = cros_ec_prepare_tx(ec_dev, msg); |
98 | if (ret < 0) |
99 | goto done; |
100 | ec_dev->dout--; |
101 | |
102 | /* send command to EC and read answer */ |
103 | ret = i2c_transfer(adap: client->adapter, msgs: i2c_msg, num: 2); |
104 | if (ret < 0) { |
105 | dev_dbg(ec_dev->dev, "i2c transfer failed: %d\n" , ret); |
106 | goto done; |
107 | } else if (ret != 2) { |
108 | dev_err(ec_dev->dev, "failed to get response: %d\n" , ret); |
109 | ret = -EIO; |
110 | goto done; |
111 | } |
112 | |
113 | ec_response_i2c = (struct ec_host_response_i2c *) in_buf; |
114 | msg->result = ec_response_i2c->result; |
115 | ec_response = &ec_response_i2c->ec_response; |
116 | |
117 | switch (msg->result) { |
118 | case EC_RES_SUCCESS: |
119 | break; |
120 | case EC_RES_IN_PROGRESS: |
121 | ret = -EAGAIN; |
122 | dev_dbg(ec_dev->dev, "command 0x%02x in progress\n" , |
123 | msg->command); |
124 | goto done; |
125 | |
126 | default: |
127 | dev_dbg(ec_dev->dev, "command 0x%02x returned %d\n" , |
128 | msg->command, msg->result); |
129 | /* |
130 | * When we send v3 request to v2 ec, ec won't recognize the |
131 | * 0xda (EC_COMMAND_PROTOCOL_3) and will return with status |
132 | * EC_RES_INVALID_COMMAND with zero data length. |
133 | * |
134 | * In case of invalid command for v3 protocol the data length |
135 | * will be at least sizeof(struct ec_host_response) |
136 | */ |
137 | if (ec_response_i2c->result == EC_RES_INVALID_COMMAND && |
138 | ec_response_i2c->packet_length == 0) { |
139 | ret = -EPROTONOSUPPORT; |
140 | goto done; |
141 | } |
142 | } |
143 | |
144 | if (ec_response_i2c->packet_length < sizeof(struct ec_host_response)) { |
145 | dev_err(ec_dev->dev, |
146 | "response of %u bytes too short; not a full header\n" , |
147 | ec_response_i2c->packet_length); |
148 | ret = -EBADMSG; |
149 | goto done; |
150 | } |
151 | |
152 | if (msg->insize < ec_response->data_len) { |
153 | dev_err(ec_dev->dev, |
154 | "response data size is too large: expected %u, got %u\n" , |
155 | msg->insize, |
156 | ec_response->data_len); |
157 | ret = -EMSGSIZE; |
158 | goto done; |
159 | } |
160 | |
161 | /* copy response packet payload and compute checksum */ |
162 | sum = 0; |
163 | for (i = 0; i < sizeof(struct ec_host_response); i++) |
164 | sum += ((u8 *)ec_response)[i]; |
165 | |
166 | memcpy(msg->data, |
167 | in_buf + response_header_size, |
168 | ec_response->data_len); |
169 | for (i = 0; i < ec_response->data_len; i++) |
170 | sum += msg->data[i]; |
171 | |
172 | /* All bytes should sum to zero */ |
173 | if (sum) { |
174 | dev_err(ec_dev->dev, "bad packet checksum\n" ); |
175 | ret = -EBADMSG; |
176 | goto done; |
177 | } |
178 | |
179 | ret = ec_response->data_len; |
180 | |
181 | done: |
182 | if (msg->command == EC_CMD_REBOOT_EC) |
183 | msleep(EC_REBOOT_DELAY_MS); |
184 | |
185 | return ret; |
186 | } |
187 | |
188 | static int cros_ec_cmd_xfer_i2c(struct cros_ec_device *ec_dev, |
189 | struct cros_ec_command *msg) |
190 | { |
191 | struct i2c_client *client = ec_dev->priv; |
192 | int ret = -ENOMEM; |
193 | int i; |
194 | int len; |
195 | int packet_len; |
196 | u8 *out_buf = NULL; |
197 | u8 *in_buf = NULL; |
198 | u8 sum; |
199 | struct i2c_msg i2c_msg[2]; |
200 | |
201 | i2c_msg[0].addr = client->addr; |
202 | i2c_msg[0].flags = 0; |
203 | i2c_msg[1].addr = client->addr; |
204 | i2c_msg[1].flags = I2C_M_RD; |
205 | |
206 | /* |
207 | * allocate larger packet (one byte for checksum, one byte for |
208 | * length, and one for result code) |
209 | */ |
210 | packet_len = msg->insize + 3; |
211 | in_buf = kzalloc(size: packet_len, GFP_KERNEL); |
212 | if (!in_buf) |
213 | goto done; |
214 | i2c_msg[1].len = packet_len; |
215 | i2c_msg[1].buf = (char *)in_buf; |
216 | |
217 | /* |
218 | * allocate larger packet (one byte for checksum, one for |
219 | * command code, one for length, and one for command version) |
220 | */ |
221 | packet_len = msg->outsize + 4; |
222 | out_buf = kzalloc(size: packet_len, GFP_KERNEL); |
223 | if (!out_buf) |
224 | goto done; |
225 | i2c_msg[0].len = packet_len; |
226 | i2c_msg[0].buf = (char *)out_buf; |
227 | |
228 | out_buf[0] = EC_CMD_VERSION0 + msg->version; |
229 | out_buf[1] = msg->command; |
230 | out_buf[2] = msg->outsize; |
231 | |
232 | /* copy message payload and compute checksum */ |
233 | sum = out_buf[0] + out_buf[1] + out_buf[2]; |
234 | for (i = 0; i < msg->outsize; i++) { |
235 | out_buf[3 + i] = msg->data[i]; |
236 | sum += out_buf[3 + i]; |
237 | } |
238 | out_buf[3 + msg->outsize] = sum; |
239 | |
240 | /* send command to EC and read answer */ |
241 | ret = i2c_transfer(adap: client->adapter, msgs: i2c_msg, num: 2); |
242 | if (ret < 0) { |
243 | dev_err(ec_dev->dev, "i2c transfer failed: %d\n" , ret); |
244 | goto done; |
245 | } else if (ret != 2) { |
246 | dev_err(ec_dev->dev, "failed to get response: %d\n" , ret); |
247 | ret = -EIO; |
248 | goto done; |
249 | } |
250 | |
251 | /* check response error code */ |
252 | msg->result = i2c_msg[1].buf[0]; |
253 | ret = cros_ec_check_result(ec_dev, msg); |
254 | if (ret) |
255 | goto done; |
256 | |
257 | len = in_buf[1]; |
258 | if (len > msg->insize) { |
259 | dev_err(ec_dev->dev, "packet too long (%d bytes, expected %d)" , |
260 | len, msg->insize); |
261 | ret = -ENOSPC; |
262 | goto done; |
263 | } |
264 | |
265 | /* copy response packet payload and compute checksum */ |
266 | sum = in_buf[0] + in_buf[1]; |
267 | for (i = 0; i < len; i++) { |
268 | msg->data[i] = in_buf[2 + i]; |
269 | sum += in_buf[2 + i]; |
270 | } |
271 | dev_dbg(ec_dev->dev, "packet: %*ph, sum = %02x\n" , |
272 | i2c_msg[1].len, in_buf, sum); |
273 | if (sum != in_buf[2 + len]) { |
274 | dev_err(ec_dev->dev, "bad packet checksum\n" ); |
275 | ret = -EBADMSG; |
276 | goto done; |
277 | } |
278 | |
279 | ret = len; |
280 | done: |
281 | kfree(objp: in_buf); |
282 | kfree(objp: out_buf); |
283 | if (msg->command == EC_CMD_REBOOT_EC) |
284 | msleep(EC_REBOOT_DELAY_MS); |
285 | |
286 | return ret; |
287 | } |
288 | |
289 | static int cros_ec_i2c_probe(struct i2c_client *client) |
290 | { |
291 | struct device *dev = &client->dev; |
292 | struct cros_ec_device *ec_dev = NULL; |
293 | int err; |
294 | |
295 | ec_dev = devm_kzalloc(dev, size: sizeof(*ec_dev), GFP_KERNEL); |
296 | if (!ec_dev) |
297 | return -ENOMEM; |
298 | |
299 | i2c_set_clientdata(client, data: ec_dev); |
300 | ec_dev->dev = dev; |
301 | ec_dev->priv = client; |
302 | ec_dev->irq = client->irq; |
303 | ec_dev->cmd_xfer = cros_ec_cmd_xfer_i2c; |
304 | ec_dev->pkt_xfer = cros_ec_pkt_xfer_i2c; |
305 | ec_dev->phys_name = client->adapter->name; |
306 | ec_dev->din_size = sizeof(struct ec_host_response_i2c) + |
307 | sizeof(struct ec_response_get_protocol_info); |
308 | ec_dev->dout_size = sizeof(struct ec_host_request_i2c); |
309 | |
310 | err = cros_ec_register(ec_dev); |
311 | if (err) { |
312 | dev_err(dev, "cannot register EC\n" ); |
313 | return err; |
314 | } |
315 | |
316 | return 0; |
317 | } |
318 | |
319 | static void cros_ec_i2c_remove(struct i2c_client *client) |
320 | { |
321 | struct cros_ec_device *ec_dev = i2c_get_clientdata(client); |
322 | |
323 | cros_ec_unregister(ec_dev); |
324 | } |
325 | |
326 | #ifdef CONFIG_PM_SLEEP |
327 | static int cros_ec_i2c_suspend(struct device *dev) |
328 | { |
329 | struct cros_ec_device *ec_dev = to_ec_dev(dev); |
330 | |
331 | return cros_ec_suspend(ec_dev); |
332 | } |
333 | |
334 | static int cros_ec_i2c_resume(struct device *dev) |
335 | { |
336 | struct cros_ec_device *ec_dev = to_ec_dev(dev); |
337 | |
338 | return cros_ec_resume(ec_dev); |
339 | } |
340 | #endif |
341 | |
342 | static const struct dev_pm_ops cros_ec_i2c_pm_ops = { |
343 | SET_LATE_SYSTEM_SLEEP_PM_OPS(cros_ec_i2c_suspend, cros_ec_i2c_resume) |
344 | }; |
345 | |
346 | #ifdef CONFIG_OF |
347 | static const struct of_device_id cros_ec_i2c_of_match[] = { |
348 | { .compatible = "google,cros-ec-i2c" , }, |
349 | { /* sentinel */ }, |
350 | }; |
351 | MODULE_DEVICE_TABLE(of, cros_ec_i2c_of_match); |
352 | #endif |
353 | |
354 | static const struct i2c_device_id cros_ec_i2c_id[] = { |
355 | { "cros-ec-i2c" , 0 }, |
356 | { } |
357 | }; |
358 | MODULE_DEVICE_TABLE(i2c, cros_ec_i2c_id); |
359 | |
360 | #ifdef CONFIG_ACPI |
361 | static const struct acpi_device_id cros_ec_i2c_acpi_id[] = { |
362 | { "GOOG0008" , 0 }, |
363 | { /* sentinel */ } |
364 | }; |
365 | MODULE_DEVICE_TABLE(acpi, cros_ec_i2c_acpi_id); |
366 | #endif |
367 | |
368 | static struct i2c_driver cros_ec_driver = { |
369 | .driver = { |
370 | .name = "cros-ec-i2c" , |
371 | .acpi_match_table = ACPI_PTR(cros_ec_i2c_acpi_id), |
372 | .of_match_table = of_match_ptr(cros_ec_i2c_of_match), |
373 | .pm = &cros_ec_i2c_pm_ops, |
374 | }, |
375 | .probe = cros_ec_i2c_probe, |
376 | .remove = cros_ec_i2c_remove, |
377 | .id_table = cros_ec_i2c_id, |
378 | }; |
379 | |
380 | module_i2c_driver(cros_ec_driver); |
381 | |
382 | MODULE_LICENSE("GPL v2" ); |
383 | MODULE_DESCRIPTION("I2C interface for ChromeOS Embedded Controller" ); |
384 | |