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