]>
Commit | Line | Data |
---|---|---|
88364387 HT |
1 | /* |
2 | * Chromium OS cros_ec driver | |
3 | * | |
4 | * Copyright (c) 2012 The Chromium OS Authors. | |
88364387 | 5 | * |
1a459660 | 6 | * SPDX-License-Identifier: GPL-2.0+ |
88364387 HT |
7 | */ |
8 | ||
9 | /* | |
836bb6e8 SG |
10 | * This is the interface to the Chrome OS EC. It provides keyboard functions, |
11 | * power control and battery management. Quite a few other functions are | |
12 | * provided to enable the EC software to be updated, talk to the EC's I2C bus | |
13 | * and store a small amount of data in a memory which persists while the EC | |
14 | * is not reset. | |
88364387 HT |
15 | */ |
16 | ||
17 | #include <common.h> | |
18 | #include <command.h> | |
84d6cbd3 | 19 | #include <dm.h> |
88364387 HT |
20 | #include <i2c.h> |
21 | #include <cros_ec.h> | |
22 | #include <fdtdec.h> | |
23 | #include <malloc.h> | |
24 | #include <spi.h> | |
1221ce45 | 25 | #include <linux/errno.h> |
88364387 HT |
26 | #include <asm/io.h> |
27 | #include <asm-generic/gpio.h> | |
84d6cbd3 SG |
28 | #include <dm/device-internal.h> |
29 | #include <dm/uclass-internal.h> | |
88364387 HT |
30 | |
31 | #ifdef DEBUG_TRACE | |
32 | #define debug_trace(fmt, b...) debug(fmt, #b) | |
33 | #else | |
34 | #define debug_trace(fmt, b...) | |
35 | #endif | |
36 | ||
37 | enum { | |
38 | /* Timeout waiting for a flash erase command to complete */ | |
39 | CROS_EC_CMD_TIMEOUT_MS = 5000, | |
40 | /* Timeout waiting for a synchronous hash to be recomputed */ | |
41 | CROS_EC_CMD_HASH_TIMEOUT_MS = 2000, | |
42 | }; | |
43 | ||
88364387 HT |
44 | DECLARE_GLOBAL_DATA_PTR; |
45 | ||
88364387 HT |
46 | void cros_ec_dump_data(const char *name, int cmd, const uint8_t *data, int len) |
47 | { | |
48 | #ifdef DEBUG | |
49 | int i; | |
50 | ||
51 | printf("%s: ", name); | |
52 | if (cmd != -1) | |
53 | printf("cmd=%#x: ", cmd); | |
54 | for (i = 0; i < len; i++) | |
55 | printf("%02x ", data[i]); | |
56 | printf("\n"); | |
57 | #endif | |
58 | } | |
59 | ||
60 | /* | |
61 | * Calculate a simple 8-bit checksum of a data block | |
62 | * | |
63 | * @param data Data block to checksum | |
64 | * @param size Size of data block in bytes | |
65 | * @return checksum value (0 to 255) | |
66 | */ | |
67 | int cros_ec_calc_checksum(const uint8_t *data, int size) | |
68 | { | |
69 | int csum, i; | |
70 | ||
71 | for (i = csum = 0; i < size; i++) | |
72 | csum += data[i]; | |
73 | return csum & 0xff; | |
74 | } | |
75 | ||
2d8ede58 SG |
76 | /** |
77 | * Create a request packet for protocol version 3. | |
78 | * | |
79 | * The packet is stored in the device's internal output buffer. | |
80 | * | |
81 | * @param dev CROS-EC device | |
82 | * @param cmd Command to send (EC_CMD_...) | |
83 | * @param cmd_version Version of command to send (EC_VER_...) | |
84 | * @param dout Output data (may be NULL If dout_len=0) | |
85 | * @param dout_len Size of output data in bytes | |
86 | * @return packet size in bytes, or <0 if error. | |
87 | */ | |
88 | static int create_proto3_request(struct cros_ec_dev *dev, | |
89 | int cmd, int cmd_version, | |
90 | const void *dout, int dout_len) | |
91 | { | |
92 | struct ec_host_request *rq = (struct ec_host_request *)dev->dout; | |
93 | int out_bytes = dout_len + sizeof(*rq); | |
94 | ||
95 | /* Fail if output size is too big */ | |
96 | if (out_bytes > (int)sizeof(dev->dout)) { | |
97 | debug("%s: Cannot send %d bytes\n", __func__, dout_len); | |
98 | return -EC_RES_REQUEST_TRUNCATED; | |
99 | } | |
100 | ||
101 | /* Fill in request packet */ | |
102 | rq->struct_version = EC_HOST_REQUEST_VERSION; | |
103 | rq->checksum = 0; | |
104 | rq->command = cmd; | |
105 | rq->command_version = cmd_version; | |
106 | rq->reserved = 0; | |
107 | rq->data_len = dout_len; | |
108 | ||
109 | /* Copy data after header */ | |
110 | memcpy(rq + 1, dout, dout_len); | |
111 | ||
112 | /* Write checksum field so the entire packet sums to 0 */ | |
113 | rq->checksum = (uint8_t)(-cros_ec_calc_checksum(dev->dout, out_bytes)); | |
114 | ||
115 | cros_ec_dump_data("out", cmd, dev->dout, out_bytes); | |
116 | ||
117 | /* Return size of request packet */ | |
118 | return out_bytes; | |
119 | } | |
120 | ||
121 | /** | |
122 | * Prepare the device to receive a protocol version 3 response. | |
123 | * | |
124 | * @param dev CROS-EC device | |
125 | * @param din_len Maximum size of response in bytes | |
126 | * @return maximum expected number of bytes in response, or <0 if error. | |
127 | */ | |
128 | static int prepare_proto3_response_buffer(struct cros_ec_dev *dev, int din_len) | |
129 | { | |
130 | int in_bytes = din_len + sizeof(struct ec_host_response); | |
131 | ||
132 | /* Fail if input size is too big */ | |
133 | if (in_bytes > (int)sizeof(dev->din)) { | |
134 | debug("%s: Cannot receive %d bytes\n", __func__, din_len); | |
135 | return -EC_RES_RESPONSE_TOO_BIG; | |
136 | } | |
137 | ||
138 | /* Return expected size of response packet */ | |
139 | return in_bytes; | |
140 | } | |
141 | ||
142 | /** | |
143 | * Handle a protocol version 3 response packet. | |
144 | * | |
145 | * The packet must already be stored in the device's internal input buffer. | |
146 | * | |
147 | * @param dev CROS-EC device | |
148 | * @param dinp Returns pointer to response data | |
149 | * @param din_len Maximum size of response in bytes | |
8bbb38b1 SG |
150 | * @return number of bytes of response data, or <0 if error. Note that error |
151 | * codes can be from errno.h or -ve EC_RES_INVALID_CHECKSUM values (and they | |
152 | * overlap!) | |
2d8ede58 SG |
153 | */ |
154 | static int handle_proto3_response(struct cros_ec_dev *dev, | |
155 | uint8_t **dinp, int din_len) | |
156 | { | |
157 | struct ec_host_response *rs = (struct ec_host_response *)dev->din; | |
158 | int in_bytes; | |
159 | int csum; | |
160 | ||
161 | cros_ec_dump_data("in-header", -1, dev->din, sizeof(*rs)); | |
162 | ||
163 | /* Check input data */ | |
164 | if (rs->struct_version != EC_HOST_RESPONSE_VERSION) { | |
165 | debug("%s: EC response version mismatch\n", __func__); | |
166 | return -EC_RES_INVALID_RESPONSE; | |
167 | } | |
168 | ||
169 | if (rs->reserved) { | |
170 | debug("%s: EC response reserved != 0\n", __func__); | |
171 | return -EC_RES_INVALID_RESPONSE; | |
172 | } | |
173 | ||
174 | if (rs->data_len > din_len) { | |
175 | debug("%s: EC returned too much data\n", __func__); | |
176 | return -EC_RES_RESPONSE_TOO_BIG; | |
177 | } | |
178 | ||
179 | cros_ec_dump_data("in-data", -1, dev->din + sizeof(*rs), rs->data_len); | |
180 | ||
181 | /* Update in_bytes to actual data size */ | |
182 | in_bytes = sizeof(*rs) + rs->data_len; | |
183 | ||
184 | /* Verify checksum */ | |
185 | csum = cros_ec_calc_checksum(dev->din, in_bytes); | |
186 | if (csum) { | |
187 | debug("%s: EC response checksum invalid: 0x%02x\n", __func__, | |
188 | csum); | |
189 | return -EC_RES_INVALID_CHECKSUM; | |
190 | } | |
191 | ||
192 | /* Return error result, if any */ | |
193 | if (rs->result) | |
194 | return -(int)rs->result; | |
195 | ||
196 | /* If we're still here, set response data pointer and return length */ | |
197 | *dinp = (uint8_t *)(rs + 1); | |
198 | ||
199 | return rs->data_len; | |
200 | } | |
201 | ||
202 | static int send_command_proto3(struct cros_ec_dev *dev, | |
203 | int cmd, int cmd_version, | |
204 | const void *dout, int dout_len, | |
205 | uint8_t **dinp, int din_len) | |
206 | { | |
84d6cbd3 | 207 | struct dm_cros_ec_ops *ops; |
2d8ede58 SG |
208 | int out_bytes, in_bytes; |
209 | int rv; | |
210 | ||
211 | /* Create request packet */ | |
212 | out_bytes = create_proto3_request(dev, cmd, cmd_version, | |
213 | dout, dout_len); | |
214 | if (out_bytes < 0) | |
215 | return out_bytes; | |
216 | ||
217 | /* Prepare response buffer */ | |
218 | in_bytes = prepare_proto3_response_buffer(dev, din_len); | |
219 | if (in_bytes < 0) | |
220 | return in_bytes; | |
221 | ||
84d6cbd3 | 222 | ops = dm_cros_ec_get_ops(dev->dev); |
8bbb38b1 | 223 | rv = ops->packet ? ops->packet(dev->dev, out_bytes, in_bytes) : -ENOSYS; |
2d8ede58 SG |
224 | if (rv < 0) |
225 | return rv; | |
226 | ||
227 | /* Process the response */ | |
228 | return handle_proto3_response(dev, dinp, din_len); | |
229 | } | |
230 | ||
88364387 HT |
231 | static int send_command(struct cros_ec_dev *dev, uint8_t cmd, int cmd_version, |
232 | const void *dout, int dout_len, | |
233 | uint8_t **dinp, int din_len) | |
234 | { | |
84d6cbd3 | 235 | struct dm_cros_ec_ops *ops; |
2d8ede58 SG |
236 | int ret = -1; |
237 | ||
238 | /* Handle protocol version 3 support */ | |
239 | if (dev->protocol_version == 3) { | |
240 | return send_command_proto3(dev, cmd, cmd_version, | |
241 | dout, dout_len, dinp, din_len); | |
242 | } | |
88364387 | 243 | |
84d6cbd3 SG |
244 | ops = dm_cros_ec_get_ops(dev->dev); |
245 | ret = ops->command(dev->dev, cmd, cmd_version, | |
246 | (const uint8_t *)dout, dout_len, dinp, din_len); | |
88364387 HT |
247 | |
248 | return ret; | |
249 | } | |
250 | ||
251 | /** | |
252 | * Send a command to the CROS-EC device and return the reply. | |
253 | * | |
254 | * The device's internal input/output buffers are used. | |
255 | * | |
256 | * @param dev CROS-EC device | |
257 | * @param cmd Command to send (EC_CMD_...) | |
258 | * @param cmd_version Version of command to send (EC_VER_...) | |
259 | * @param dout Output data (may be NULL If dout_len=0) | |
260 | * @param dout_len Size of output data in bytes | |
261 | * @param dinp Response data (may be NULL If din_len=0). | |
262 | * If not NULL, it will be updated to point to the data | |
263 | * and will always be double word aligned (64-bits) | |
264 | * @param din_len Maximum size of response in bytes | |
8bbb38b1 | 265 | * @return number of bytes in response, or -ve on error |
88364387 HT |
266 | */ |
267 | static int ec_command_inptr(struct cros_ec_dev *dev, uint8_t cmd, | |
268 | int cmd_version, const void *dout, int dout_len, uint8_t **dinp, | |
269 | int din_len) | |
270 | { | |
2ab83f0d | 271 | uint8_t *din = NULL; |
88364387 HT |
272 | int len; |
273 | ||
88364387 HT |
274 | len = send_command(dev, cmd, cmd_version, dout, dout_len, |
275 | &din, din_len); | |
276 | ||
277 | /* If the command doesn't complete, wait a while */ | |
278 | if (len == -EC_RES_IN_PROGRESS) { | |
2ab83f0d | 279 | struct ec_response_get_comms_status *resp = NULL; |
88364387 HT |
280 | ulong start; |
281 | ||
282 | /* Wait for command to complete */ | |
283 | start = get_timer(0); | |
284 | do { | |
285 | int ret; | |
286 | ||
287 | mdelay(50); /* Insert some reasonable delay */ | |
288 | ret = send_command(dev, EC_CMD_GET_COMMS_STATUS, 0, | |
289 | NULL, 0, | |
290 | (uint8_t **)&resp, sizeof(*resp)); | |
291 | if (ret < 0) | |
292 | return ret; | |
293 | ||
294 | if (get_timer(start) > CROS_EC_CMD_TIMEOUT_MS) { | |
295 | debug("%s: Command %#02x timeout\n", | |
296 | __func__, cmd); | |
297 | return -EC_RES_TIMEOUT; | |
298 | } | |
299 | } while (resp->flags & EC_COMMS_STATUS_PROCESSING); | |
300 | ||
301 | /* OK it completed, so read the status response */ | |
302 | /* not sure why it was 0 for the last argument */ | |
303 | len = send_command(dev, EC_CMD_RESEND_RESPONSE, 0, | |
304 | NULL, 0, &din, din_len); | |
305 | } | |
306 | ||
2ab83f0d SG |
307 | debug("%s: len=%d, dinp=%p, *dinp=%p\n", __func__, len, dinp, |
308 | dinp ? *dinp : NULL); | |
88364387 HT |
309 | if (dinp) { |
310 | /* If we have any data to return, it must be 64bit-aligned */ | |
311 | assert(len <= 0 || !((uintptr_t)din & 7)); | |
312 | *dinp = din; | |
313 | } | |
314 | ||
315 | return len; | |
316 | } | |
317 | ||
318 | /** | |
319 | * Send a command to the CROS-EC device and return the reply. | |
320 | * | |
321 | * The device's internal input/output buffers are used. | |
322 | * | |
323 | * @param dev CROS-EC device | |
324 | * @param cmd Command to send (EC_CMD_...) | |
325 | * @param cmd_version Version of command to send (EC_VER_...) | |
326 | * @param dout Output data (may be NULL If dout_len=0) | |
327 | * @param dout_len Size of output data in bytes | |
328 | * @param din Response data (may be NULL If din_len=0). | |
329 | * It not NULL, it is a place for ec_command() to copy the | |
330 | * data to. | |
331 | * @param din_len Maximum size of response in bytes | |
8bbb38b1 | 332 | * @return number of bytes in response, or -ve on error |
88364387 HT |
333 | */ |
334 | static int ec_command(struct cros_ec_dev *dev, uint8_t cmd, int cmd_version, | |
335 | const void *dout, int dout_len, | |
336 | void *din, int din_len) | |
337 | { | |
338 | uint8_t *in_buffer; | |
339 | int len; | |
340 | ||
341 | assert((din_len == 0) || din); | |
342 | len = ec_command_inptr(dev, cmd, cmd_version, dout, dout_len, | |
343 | &in_buffer, din_len); | |
344 | if (len > 0) { | |
345 | /* | |
346 | * If we were asked to put it somewhere, do so, otherwise just | |
347 | * disregard the result. | |
348 | */ | |
349 | if (din && in_buffer) { | |
350 | assert(len <= din_len); | |
351 | memmove(din, in_buffer, len); | |
352 | } | |
353 | } | |
354 | return len; | |
355 | } | |
356 | ||
745009c4 | 357 | int cros_ec_scan_keyboard(struct udevice *dev, struct mbkp_keyscan *scan) |
88364387 | 358 | { |
745009c4 SG |
359 | struct cros_ec_dev *cdev = dev_get_uclass_priv(dev); |
360 | ||
361 | if (ec_command(cdev, EC_CMD_MKBP_STATE, 0, NULL, 0, scan, | |
2ab83f0d | 362 | sizeof(scan->data)) != sizeof(scan->data)) |
88364387 HT |
363 | return -1; |
364 | ||
365 | return 0; | |
366 | } | |
367 | ||
368 | int cros_ec_read_id(struct cros_ec_dev *dev, char *id, int maxlen) | |
369 | { | |
370 | struct ec_response_get_version *r; | |
371 | ||
372 | if (ec_command_inptr(dev, EC_CMD_GET_VERSION, 0, NULL, 0, | |
2ab83f0d | 373 | (uint8_t **)&r, sizeof(*r)) != sizeof(*r)) |
88364387 HT |
374 | return -1; |
375 | ||
2ab83f0d | 376 | if (maxlen > (int)sizeof(r->version_string_ro)) |
88364387 HT |
377 | maxlen = sizeof(r->version_string_ro); |
378 | ||
379 | switch (r->current_image) { | |
380 | case EC_IMAGE_RO: | |
381 | memcpy(id, r->version_string_ro, maxlen); | |
382 | break; | |
383 | case EC_IMAGE_RW: | |
384 | memcpy(id, r->version_string_rw, maxlen); | |
385 | break; | |
386 | default: | |
387 | return -1; | |
388 | } | |
389 | ||
390 | id[maxlen - 1] = '\0'; | |
391 | return 0; | |
392 | } | |
393 | ||
394 | int cros_ec_read_version(struct cros_ec_dev *dev, | |
395 | struct ec_response_get_version **versionp) | |
396 | { | |
397 | if (ec_command_inptr(dev, EC_CMD_GET_VERSION, 0, NULL, 0, | |
398 | (uint8_t **)versionp, sizeof(**versionp)) | |
2ab83f0d | 399 | != sizeof(**versionp)) |
88364387 HT |
400 | return -1; |
401 | ||
402 | return 0; | |
403 | } | |
404 | ||
405 | int cros_ec_read_build_info(struct cros_ec_dev *dev, char **strp) | |
406 | { | |
407 | if (ec_command_inptr(dev, EC_CMD_GET_BUILD_INFO, 0, NULL, 0, | |
836bb6e8 | 408 | (uint8_t **)strp, EC_PROTO2_MAX_PARAM_SIZE) < 0) |
88364387 HT |
409 | return -1; |
410 | ||
411 | return 0; | |
412 | } | |
413 | ||
414 | int cros_ec_read_current_image(struct cros_ec_dev *dev, | |
415 | enum ec_current_image *image) | |
416 | { | |
417 | struct ec_response_get_version *r; | |
418 | ||
419 | if (ec_command_inptr(dev, EC_CMD_GET_VERSION, 0, NULL, 0, | |
2ab83f0d | 420 | (uint8_t **)&r, sizeof(*r)) != sizeof(*r)) |
88364387 HT |
421 | return -1; |
422 | ||
423 | *image = r->current_image; | |
424 | return 0; | |
425 | } | |
426 | ||
427 | static int cros_ec_wait_on_hash_done(struct cros_ec_dev *dev, | |
428 | struct ec_response_vboot_hash *hash) | |
429 | { | |
430 | struct ec_params_vboot_hash p; | |
431 | ulong start; | |
432 | ||
433 | start = get_timer(0); | |
434 | while (hash->status == EC_VBOOT_HASH_STATUS_BUSY) { | |
435 | mdelay(50); /* Insert some reasonable delay */ | |
436 | ||
437 | p.cmd = EC_VBOOT_HASH_GET; | |
438 | if (ec_command(dev, EC_CMD_VBOOT_HASH, 0, &p, sizeof(p), | |
439 | hash, sizeof(*hash)) < 0) | |
440 | return -1; | |
441 | ||
442 | if (get_timer(start) > CROS_EC_CMD_HASH_TIMEOUT_MS) { | |
443 | debug("%s: EC_VBOOT_HASH_GET timeout\n", __func__); | |
444 | return -EC_RES_TIMEOUT; | |
445 | } | |
446 | } | |
447 | return 0; | |
448 | } | |
449 | ||
450 | ||
451 | int cros_ec_read_hash(struct cros_ec_dev *dev, | |
452 | struct ec_response_vboot_hash *hash) | |
453 | { | |
454 | struct ec_params_vboot_hash p; | |
455 | int rv; | |
456 | ||
457 | p.cmd = EC_VBOOT_HASH_GET; | |
458 | if (ec_command(dev, EC_CMD_VBOOT_HASH, 0, &p, sizeof(p), | |
459 | hash, sizeof(*hash)) < 0) | |
460 | return -1; | |
461 | ||
462 | /* If the EC is busy calculating the hash, fidget until it's done. */ | |
463 | rv = cros_ec_wait_on_hash_done(dev, hash); | |
464 | if (rv) | |
465 | return rv; | |
466 | ||
467 | /* If the hash is valid, we're done. Otherwise, we have to kick it off | |
468 | * again and wait for it to complete. Note that we explicitly assume | |
469 | * that hashing zero bytes is always wrong, even though that would | |
470 | * produce a valid hash value. */ | |
471 | if (hash->status == EC_VBOOT_HASH_STATUS_DONE && hash->size) | |
472 | return 0; | |
473 | ||
474 | debug("%s: No valid hash (status=%d size=%d). Compute one...\n", | |
475 | __func__, hash->status, hash->size); | |
476 | ||
836bb6e8 | 477 | p.cmd = EC_VBOOT_HASH_START; |
88364387 HT |
478 | p.hash_type = EC_VBOOT_HASH_TYPE_SHA256; |
479 | p.nonce_size = 0; | |
480 | p.offset = EC_VBOOT_HASH_OFFSET_RW; | |
481 | ||
482 | if (ec_command(dev, EC_CMD_VBOOT_HASH, 0, &p, sizeof(p), | |
483 | hash, sizeof(*hash)) < 0) | |
484 | return -1; | |
485 | ||
486 | rv = cros_ec_wait_on_hash_done(dev, hash); | |
487 | if (rv) | |
488 | return rv; | |
489 | ||
490 | debug("%s: hash done\n", __func__); | |
491 | ||
492 | return 0; | |
493 | } | |
494 | ||
495 | static int cros_ec_invalidate_hash(struct cros_ec_dev *dev) | |
496 | { | |
497 | struct ec_params_vboot_hash p; | |
498 | struct ec_response_vboot_hash *hash; | |
499 | ||
500 | /* We don't have an explict command for the EC to discard its current | |
501 | * hash value, so we'll just tell it to calculate one that we know is | |
502 | * wrong (we claim that hashing zero bytes is always invalid). | |
503 | */ | |
504 | p.cmd = EC_VBOOT_HASH_RECALC; | |
505 | p.hash_type = EC_VBOOT_HASH_TYPE_SHA256; | |
506 | p.nonce_size = 0; | |
507 | p.offset = 0; | |
508 | p.size = 0; | |
509 | ||
510 | debug("%s:\n", __func__); | |
511 | ||
512 | if (ec_command_inptr(dev, EC_CMD_VBOOT_HASH, 0, &p, sizeof(p), | |
513 | (uint8_t **)&hash, sizeof(*hash)) < 0) | |
514 | return -1; | |
515 | ||
516 | /* No need to wait for it to finish */ | |
517 | return 0; | |
518 | } | |
519 | ||
520 | int cros_ec_reboot(struct cros_ec_dev *dev, enum ec_reboot_cmd cmd, | |
521 | uint8_t flags) | |
522 | { | |
523 | struct ec_params_reboot_ec p; | |
524 | ||
525 | p.cmd = cmd; | |
526 | p.flags = flags; | |
527 | ||
528 | if (ec_command_inptr(dev, EC_CMD_REBOOT_EC, 0, &p, sizeof(p), NULL, 0) | |
529 | < 0) | |
530 | return -1; | |
531 | ||
532 | if (!(flags & EC_REBOOT_FLAG_ON_AP_SHUTDOWN)) { | |
533 | /* | |
534 | * EC reboot will take place immediately so delay to allow it | |
535 | * to complete. Note that some reboot types (EC_REBOOT_COLD) | |
536 | * will reboot the AP as well, in which case we won't actually | |
537 | * get to this point. | |
538 | */ | |
539 | /* | |
540 | * TODO(rspangler@chromium.org): Would be nice if we had a | |
541 | * better way to determine when the reboot is complete. Could | |
542 | * we poll a memory-mapped LPC value? | |
543 | */ | |
544 | udelay(50000); | |
545 | } | |
546 | ||
547 | return 0; | |
548 | } | |
549 | ||
745009c4 | 550 | int cros_ec_interrupt_pending(struct udevice *dev) |
88364387 | 551 | { |
745009c4 SG |
552 | struct cros_ec_dev *cdev = dev_get_uclass_priv(dev); |
553 | ||
88364387 | 554 | /* no interrupt support : always poll */ |
745009c4 | 555 | if (!dm_gpio_is_valid(&cdev->ec_int)) |
2ab83f0d | 556 | return -ENOENT; |
88364387 | 557 | |
745009c4 | 558 | return dm_gpio_get_value(&cdev->ec_int); |
88364387 HT |
559 | } |
560 | ||
836bb6e8 | 561 | int cros_ec_info(struct cros_ec_dev *dev, struct ec_response_mkbp_info *info) |
88364387 | 562 | { |
836bb6e8 | 563 | if (ec_command(dev, EC_CMD_MKBP_INFO, 0, NULL, 0, info, |
2ab83f0d | 564 | sizeof(*info)) != sizeof(*info)) |
88364387 HT |
565 | return -1; |
566 | ||
567 | return 0; | |
568 | } | |
569 | ||
570 | int cros_ec_get_host_events(struct cros_ec_dev *dev, uint32_t *events_ptr) | |
571 | { | |
572 | struct ec_response_host_event_mask *resp; | |
573 | ||
574 | /* | |
575 | * Use the B copy of the event flags, because the main copy is already | |
576 | * used by ACPI/SMI. | |
577 | */ | |
578 | if (ec_command_inptr(dev, EC_CMD_HOST_EVENT_GET_B, 0, NULL, 0, | |
2ab83f0d | 579 | (uint8_t **)&resp, sizeof(*resp)) < (int)sizeof(*resp)) |
88364387 HT |
580 | return -1; |
581 | ||
582 | if (resp->mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_INVALID)) | |
583 | return -1; | |
584 | ||
585 | *events_ptr = resp->mask; | |
586 | return 0; | |
587 | } | |
588 | ||
589 | int cros_ec_clear_host_events(struct cros_ec_dev *dev, uint32_t events) | |
590 | { | |
591 | struct ec_params_host_event_mask params; | |
592 | ||
593 | params.mask = events; | |
594 | ||
595 | /* | |
596 | * Use the B copy of the event flags, so it affects the data returned | |
597 | * by cros_ec_get_host_events(). | |
598 | */ | |
599 | if (ec_command_inptr(dev, EC_CMD_HOST_EVENT_CLEAR_B, 0, | |
600 | ¶ms, sizeof(params), NULL, 0) < 0) | |
601 | return -1; | |
602 | ||
603 | return 0; | |
604 | } | |
605 | ||
606 | int cros_ec_flash_protect(struct cros_ec_dev *dev, | |
607 | uint32_t set_mask, uint32_t set_flags, | |
608 | struct ec_response_flash_protect *resp) | |
609 | { | |
610 | struct ec_params_flash_protect params; | |
611 | ||
612 | params.mask = set_mask; | |
613 | params.flags = set_flags; | |
614 | ||
615 | if (ec_command(dev, EC_CMD_FLASH_PROTECT, EC_VER_FLASH_PROTECT, | |
616 | ¶ms, sizeof(params), | |
2ab83f0d | 617 | resp, sizeof(*resp)) != sizeof(*resp)) |
88364387 HT |
618 | return -1; |
619 | ||
620 | return 0; | |
621 | } | |
622 | ||
623 | static int cros_ec_check_version(struct cros_ec_dev *dev) | |
624 | { | |
625 | struct ec_params_hello req; | |
626 | struct ec_response_hello *resp; | |
627 | ||
72a38e06 SG |
628 | struct dm_cros_ec_ops *ops; |
629 | int ret; | |
630 | ||
631 | ops = dm_cros_ec_get_ops(dev->dev); | |
632 | if (ops->check_version) { | |
633 | ret = ops->check_version(dev->dev); | |
634 | if (ret) | |
635 | return ret; | |
636 | } | |
88364387 HT |
637 | |
638 | /* | |
639 | * TODO(sjg@chromium.org). | |
640 | * There is a strange oddity here with the EC. We could just ignore | |
641 | * the response, i.e. pass the last two parameters as NULL and 0. | |
642 | * In this case we won't read back very many bytes from the EC. | |
643 | * On the I2C bus the EC gets upset about this and will try to send | |
644 | * the bytes anyway. This means that we will have to wait for that | |
645 | * to complete before continuing with a new EC command. | |
646 | * | |
647 | * This problem is probably unique to the I2C bus. | |
648 | * | |
649 | * So for now, just read all the data anyway. | |
650 | */ | |
e8c12662 | 651 | |
a6070283 RS |
652 | /* Try sending a version 3 packet */ |
653 | dev->protocol_version = 3; | |
d11e8fd8 | 654 | req.in_data = 0; |
a6070283 RS |
655 | if (ec_command_inptr(dev, EC_CMD_HELLO, 0, &req, sizeof(req), |
656 | (uint8_t **)&resp, sizeof(*resp)) > 0) { | |
657 | return 0; | |
658 | } | |
659 | ||
e8c12662 RS |
660 | /* Try sending a version 2 packet */ |
661 | dev->protocol_version = 2; | |
88364387 HT |
662 | if (ec_command_inptr(dev, EC_CMD_HELLO, 0, &req, sizeof(req), |
663 | (uint8_t **)&resp, sizeof(*resp)) > 0) { | |
e8c12662 | 664 | return 0; |
88364387 HT |
665 | } |
666 | ||
e8c12662 RS |
667 | /* |
668 | * Fail if we're still here, since the EC doesn't understand any | |
669 | * protcol version we speak. Version 1 interface without command | |
670 | * version is no longer supported, and we don't know about any new | |
671 | * protocol versions. | |
672 | */ | |
673 | dev->protocol_version = 0; | |
674 | printf("%s: ERROR: old EC interface not supported\n", __func__); | |
675 | return -1; | |
88364387 HT |
676 | } |
677 | ||
678 | int cros_ec_test(struct cros_ec_dev *dev) | |
679 | { | |
680 | struct ec_params_hello req; | |
681 | struct ec_response_hello *resp; | |
682 | ||
683 | req.in_data = 0x12345678; | |
684 | if (ec_command_inptr(dev, EC_CMD_HELLO, 0, &req, sizeof(req), | |
685 | (uint8_t **)&resp, sizeof(*resp)) < sizeof(*resp)) { | |
686 | printf("ec_command_inptr() returned error\n"); | |
687 | return -1; | |
688 | } | |
689 | if (resp->out_data != req.in_data + 0x01020304) { | |
690 | printf("Received invalid handshake %x\n", resp->out_data); | |
691 | return -1; | |
692 | } | |
693 | ||
694 | return 0; | |
695 | } | |
696 | ||
697 | int cros_ec_flash_offset(struct cros_ec_dev *dev, enum ec_flash_region region, | |
698 | uint32_t *offset, uint32_t *size) | |
699 | { | |
700 | struct ec_params_flash_region_info p; | |
701 | struct ec_response_flash_region_info *r; | |
702 | int ret; | |
703 | ||
704 | p.region = region; | |
705 | ret = ec_command_inptr(dev, EC_CMD_FLASH_REGION_INFO, | |
706 | EC_VER_FLASH_REGION_INFO, | |
707 | &p, sizeof(p), (uint8_t **)&r, sizeof(*r)); | |
708 | if (ret != sizeof(*r)) | |
709 | return -1; | |
710 | ||
711 | if (offset) | |
712 | *offset = r->offset; | |
713 | if (size) | |
714 | *size = r->size; | |
715 | ||
716 | return 0; | |
717 | } | |
718 | ||
719 | int cros_ec_flash_erase(struct cros_ec_dev *dev, uint32_t offset, uint32_t size) | |
720 | { | |
721 | struct ec_params_flash_erase p; | |
722 | ||
723 | p.offset = offset; | |
724 | p.size = size; | |
725 | return ec_command_inptr(dev, EC_CMD_FLASH_ERASE, 0, &p, sizeof(p), | |
726 | NULL, 0); | |
727 | } | |
728 | ||
729 | /** | |
730 | * Write a single block to the flash | |
731 | * | |
732 | * Write a block of data to the EC flash. The size must not exceed the flash | |
733 | * write block size which you can obtain from cros_ec_flash_write_burst_size(). | |
734 | * | |
735 | * The offset starts at 0. You can obtain the region information from | |
736 | * cros_ec_flash_offset() to find out where to write for a particular region. | |
737 | * | |
738 | * Attempting to write to the region where the EC is currently running from | |
739 | * will result in an error. | |
740 | * | |
741 | * @param dev CROS-EC device | |
742 | * @param data Pointer to data buffer to write | |
743 | * @param offset Offset within flash to write to. | |
744 | * @param size Number of bytes to write | |
745 | * @return 0 if ok, -1 on error | |
746 | */ | |
747 | static int cros_ec_flash_write_block(struct cros_ec_dev *dev, | |
748 | const uint8_t *data, uint32_t offset, uint32_t size) | |
749 | { | |
bae5b97e MF |
750 | struct ec_params_flash_write *p; |
751 | int ret; | |
88364387 | 752 | |
bae5b97e MF |
753 | p = malloc(sizeof(*p) + size); |
754 | if (!p) | |
755 | return -ENOMEM; | |
756 | ||
757 | p->offset = offset; | |
758 | p->size = size; | |
759 | assert(data && p->size <= EC_FLASH_WRITE_VER0_SIZE); | |
760 | memcpy(p + 1, data, p->size); | |
88364387 | 761 | |
bae5b97e MF |
762 | ret = ec_command_inptr(dev, EC_CMD_FLASH_WRITE, 0, |
763 | p, sizeof(*p) + size, NULL, 0) >= 0 ? 0 : -1; | |
764 | ||
765 | free(p); | |
766 | ||
767 | return ret; | |
88364387 HT |
768 | } |
769 | ||
770 | /** | |
771 | * Return optimal flash write burst size | |
772 | */ | |
773 | static int cros_ec_flash_write_burst_size(struct cros_ec_dev *dev) | |
774 | { | |
836bb6e8 | 775 | return EC_FLASH_WRITE_VER0_SIZE; |
88364387 HT |
776 | } |
777 | ||
778 | /** | |
779 | * Check if a block of data is erased (all 0xff) | |
780 | * | |
781 | * This function is useful when dealing with flash, for checking whether a | |
782 | * data block is erased and thus does not need to be programmed. | |
783 | * | |
784 | * @param data Pointer to data to check (must be word-aligned) | |
785 | * @param size Number of bytes to check (must be word-aligned) | |
786 | * @return 0 if erased, non-zero if any word is not erased | |
787 | */ | |
788 | static int cros_ec_data_is_erased(const uint32_t *data, int size) | |
789 | { | |
790 | assert(!(size & 3)); | |
791 | size /= sizeof(uint32_t); | |
792 | for (; size > 0; size -= 4, data++) | |
793 | if (*data != -1U) | |
794 | return 0; | |
795 | ||
796 | return 1; | |
797 | } | |
798 | ||
281ca88f MF |
799 | /** |
800 | * Read back flash parameters | |
801 | * | |
802 | * This function reads back parameters of the flash as reported by the EC | |
803 | * | |
804 | * @param dev Pointer to device | |
805 | * @param info Pointer to output flash info struct | |
806 | */ | |
807 | int cros_ec_read_flashinfo(struct cros_ec_dev *dev, | |
808 | struct ec_response_flash_info *info) | |
809 | { | |
810 | int ret; | |
811 | ||
812 | ret = ec_command(dev, EC_CMD_FLASH_INFO, 0, | |
813 | NULL, 0, info, sizeof(*info)); | |
814 | if (ret < 0) | |
815 | return ret; | |
816 | ||
817 | return ret < sizeof(*info) ? -1 : 0; | |
818 | } | |
819 | ||
88364387 HT |
820 | int cros_ec_flash_write(struct cros_ec_dev *dev, const uint8_t *data, |
821 | uint32_t offset, uint32_t size) | |
822 | { | |
823 | uint32_t burst = cros_ec_flash_write_burst_size(dev); | |
824 | uint32_t end, off; | |
825 | int ret; | |
826 | ||
827 | /* | |
828 | * TODO: round up to the nearest multiple of write size. Can get away | |
829 | * without that on link right now because its write size is 4 bytes. | |
830 | */ | |
831 | end = offset + size; | |
832 | for (off = offset; off < end; off += burst, data += burst) { | |
833 | uint32_t todo; | |
834 | ||
835 | /* If the data is empty, there is no point in programming it */ | |
836 | todo = min(end - off, burst); | |
837 | if (dev->optimise_flash_write && | |
838 | cros_ec_data_is_erased((uint32_t *)data, todo)) | |
839 | continue; | |
840 | ||
841 | ret = cros_ec_flash_write_block(dev, data, off, todo); | |
842 | if (ret) | |
843 | return ret; | |
844 | } | |
845 | ||
846 | return 0; | |
847 | } | |
848 | ||
849 | /** | |
850 | * Read a single block from the flash | |
851 | * | |
852 | * Read a block of data from the EC flash. The size must not exceed the flash | |
853 | * write block size which you can obtain from cros_ec_flash_write_burst_size(). | |
854 | * | |
855 | * The offset starts at 0. You can obtain the region information from | |
856 | * cros_ec_flash_offset() to find out where to read for a particular region. | |
857 | * | |
858 | * @param dev CROS-EC device | |
859 | * @param data Pointer to data buffer to read into | |
860 | * @param offset Offset within flash to read from | |
861 | * @param size Number of bytes to read | |
862 | * @return 0 if ok, -1 on error | |
863 | */ | |
864 | static int cros_ec_flash_read_block(struct cros_ec_dev *dev, uint8_t *data, | |
865 | uint32_t offset, uint32_t size) | |
866 | { | |
867 | struct ec_params_flash_read p; | |
868 | ||
869 | p.offset = offset; | |
870 | p.size = size; | |
871 | ||
872 | return ec_command(dev, EC_CMD_FLASH_READ, 0, | |
873 | &p, sizeof(p), data, size) >= 0 ? 0 : -1; | |
874 | } | |
875 | ||
876 | int cros_ec_flash_read(struct cros_ec_dev *dev, uint8_t *data, uint32_t offset, | |
877 | uint32_t size) | |
878 | { | |
879 | uint32_t burst = cros_ec_flash_write_burst_size(dev); | |
880 | uint32_t end, off; | |
881 | int ret; | |
882 | ||
883 | end = offset + size; | |
884 | for (off = offset; off < end; off += burst, data += burst) { | |
885 | ret = cros_ec_flash_read_block(dev, data, off, | |
886 | min(end - off, burst)); | |
887 | if (ret) | |
888 | return ret; | |
889 | } | |
890 | ||
891 | return 0; | |
892 | } | |
893 | ||
894 | int cros_ec_flash_update_rw(struct cros_ec_dev *dev, | |
895 | const uint8_t *image, int image_size) | |
896 | { | |
897 | uint32_t rw_offset, rw_size; | |
898 | int ret; | |
899 | ||
900 | if (cros_ec_flash_offset(dev, EC_FLASH_REGION_RW, &rw_offset, &rw_size)) | |
901 | return -1; | |
2ab83f0d | 902 | if (image_size > (int)rw_size) |
88364387 HT |
903 | return -1; |
904 | ||
905 | /* Invalidate the existing hash, just in case the AP reboots | |
906 | * unexpectedly during the update. If that happened, the EC RW firmware | |
907 | * would be invalid, but the EC would still have the original hash. | |
908 | */ | |
909 | ret = cros_ec_invalidate_hash(dev); | |
910 | if (ret) | |
911 | return ret; | |
912 | ||
913 | /* | |
914 | * Erase the entire RW section, so that the EC doesn't see any garbage | |
915 | * past the new image if it's smaller than the current image. | |
916 | * | |
917 | * TODO: could optimize this to erase just the current image, since | |
918 | * presumably everything past that is 0xff's. But would still need to | |
919 | * round up to the nearest multiple of erase size. | |
920 | */ | |
921 | ret = cros_ec_flash_erase(dev, rw_offset, rw_size); | |
922 | if (ret) | |
923 | return ret; | |
924 | ||
925 | /* Write the image */ | |
926 | ret = cros_ec_flash_write(dev, image, rw_offset, image_size); | |
927 | if (ret) | |
928 | return ret; | |
929 | ||
930 | return 0; | |
931 | } | |
932 | ||
933 | int cros_ec_read_vbnvcontext(struct cros_ec_dev *dev, uint8_t *block) | |
934 | { | |
935 | struct ec_params_vbnvcontext p; | |
936 | int len; | |
937 | ||
938 | p.op = EC_VBNV_CONTEXT_OP_READ; | |
939 | ||
940 | len = ec_command(dev, EC_CMD_VBNV_CONTEXT, EC_VER_VBNV_CONTEXT, | |
941 | &p, sizeof(p), block, EC_VBNV_BLOCK_SIZE); | |
942 | if (len < EC_VBNV_BLOCK_SIZE) | |
943 | return -1; | |
944 | ||
945 | return 0; | |
946 | } | |
947 | ||
948 | int cros_ec_write_vbnvcontext(struct cros_ec_dev *dev, const uint8_t *block) | |
949 | { | |
950 | struct ec_params_vbnvcontext p; | |
951 | int len; | |
952 | ||
953 | p.op = EC_VBNV_CONTEXT_OP_WRITE; | |
954 | memcpy(p.block, block, sizeof(p.block)); | |
955 | ||
956 | len = ec_command_inptr(dev, EC_CMD_VBNV_CONTEXT, EC_VER_VBNV_CONTEXT, | |
957 | &p, sizeof(p), NULL, 0); | |
958 | if (len < 0) | |
959 | return -1; | |
960 | ||
961 | return 0; | |
962 | } | |
963 | ||
f48eaf01 | 964 | int cros_ec_set_ldo(struct udevice *dev, uint8_t index, uint8_t state) |
88364387 | 965 | { |
f48eaf01 | 966 | struct cros_ec_dev *cdev = dev_get_uclass_priv(dev); |
88364387 HT |
967 | struct ec_params_ldo_set params; |
968 | ||
969 | params.index = index; | |
970 | params.state = state; | |
971 | ||
f48eaf01 SG |
972 | if (ec_command_inptr(cdev, EC_CMD_LDO_SET, 0, ¶ms, sizeof(params), |
973 | NULL, 0)) | |
88364387 HT |
974 | return -1; |
975 | ||
976 | return 0; | |
977 | } | |
978 | ||
f48eaf01 | 979 | int cros_ec_get_ldo(struct udevice *dev, uint8_t index, uint8_t *state) |
88364387 | 980 | { |
f48eaf01 | 981 | struct cros_ec_dev *cdev = dev_get_uclass_priv(dev); |
88364387 HT |
982 | struct ec_params_ldo_get params; |
983 | struct ec_response_ldo_get *resp; | |
984 | ||
985 | params.index = index; | |
986 | ||
f48eaf01 SG |
987 | if (ec_command_inptr(cdev, EC_CMD_LDO_GET, 0, ¶ms, sizeof(params), |
988 | (uint8_t **)&resp, sizeof(*resp)) != | |
989 | sizeof(*resp)) | |
88364387 HT |
990 | return -1; |
991 | ||
992 | *state = resp->state; | |
993 | ||
994 | return 0; | |
995 | } | |
996 | ||
84d6cbd3 | 997 | int cros_ec_register(struct udevice *dev) |
88364387 | 998 | { |
e564f054 | 999 | struct cros_ec_dev *cdev = dev_get_uclass_priv(dev); |
84d6cbd3 | 1000 | const void *blob = gd->fdt_blob; |
e160f7d4 | 1001 | int node = dev_of_offset(dev); |
88364387 | 1002 | char id[MSG_BYTES]; |
84d6cbd3 SG |
1003 | |
1004 | cdev->dev = dev; | |
32f8a19f SG |
1005 | gpio_request_by_name(dev, "ec-interrupt", 0, &cdev->ec_int, |
1006 | GPIOD_IS_IN); | |
84d6cbd3 SG |
1007 | cdev->optimise_flash_write = fdtdec_get_bool(blob, node, |
1008 | "optimise-flash-write"); | |
1009 | ||
84d6cbd3 SG |
1010 | if (cros_ec_check_version(cdev)) { |
1011 | debug("%s: Could not detect CROS-EC version\n", __func__); | |
1012 | return -CROS_EC_ERR_CHECK_VERSION; | |
1013 | } | |
1014 | ||
1015 | if (cros_ec_read_id(cdev, id, sizeof(id))) { | |
1016 | debug("%s: Could not read KBC ID\n", __func__); | |
1017 | return -CROS_EC_ERR_READ_ID; | |
1018 | } | |
1019 | ||
1020 | /* Remember this device for use by the cros_ec command */ | |
c4b206df SG |
1021 | debug("Google Chrome EC v%d CROS-EC driver ready, id '%s'\n", |
1022 | cdev->protocol_version, id); | |
84d6cbd3 SG |
1023 | |
1024 | return 0; | |
1025 | } | |
88364387 | 1026 | |
84d6cbd3 SG |
1027 | int cros_ec_decode_ec_flash(const void *blob, int node, |
1028 | struct fdt_cros_ec *config) | |
d7f25f35 | 1029 | { |
84d6cbd3 | 1030 | int flash_node; |
d7f25f35 SG |
1031 | |
1032 | flash_node = fdt_subnode_offset(blob, node, "flash"); | |
1033 | if (flash_node < 0) { | |
1034 | debug("Failed to find flash node\n"); | |
1035 | return -1; | |
1036 | } | |
1037 | ||
1038 | if (fdtdec_read_fmap_entry(blob, flash_node, "flash", | |
1039 | &config->flash)) { | |
1040 | debug("Failed to decode flash node in chrome-ec'\n"); | |
1041 | return -1; | |
1042 | } | |
1043 | ||
1044 | config->flash_erase_value = fdtdec_get_int(blob, flash_node, | |
1045 | "erase-value", -1); | |
1046 | for (node = fdt_first_subnode(blob, flash_node); node >= 0; | |
1047 | node = fdt_next_subnode(blob, node)) { | |
1048 | const char *name = fdt_get_name(blob, node, NULL); | |
1049 | enum ec_flash_region region; | |
1050 | ||
1051 | if (0 == strcmp(name, "ro")) { | |
1052 | region = EC_FLASH_REGION_RO; | |
1053 | } else if (0 == strcmp(name, "rw")) { | |
1054 | region = EC_FLASH_REGION_RW; | |
1055 | } else if (0 == strcmp(name, "wp-ro")) { | |
1056 | region = EC_FLASH_REGION_WP_RO; | |
1057 | } else { | |
1058 | debug("Unknown EC flash region name '%s'\n", name); | |
1059 | return -1; | |
1060 | } | |
1061 | ||
1062 | if (fdtdec_read_fmap_entry(blob, node, "reg", | |
1063 | &config->region[region])) { | |
1064 | debug("Failed to decode flash region in chrome-ec'\n"); | |
1065 | return -1; | |
1066 | } | |
1067 | } | |
1068 | ||
1069 | return 0; | |
1070 | } | |
1071 | ||
6d1a718f MF |
1072 | int cros_ec_i2c_tunnel(struct udevice *dev, int port, struct i2c_msg *in, |
1073 | int nmsgs) | |
cc456bd7 SG |
1074 | { |
1075 | struct cros_ec_dev *cdev = dev_get_uclass_priv(dev); | |
1076 | union { | |
1077 | struct ec_params_i2c_passthru p; | |
1078 | uint8_t outbuf[EC_PROTO2_MAX_PARAM_SIZE]; | |
1079 | } params; | |
1080 | union { | |
1081 | struct ec_response_i2c_passthru r; | |
1082 | uint8_t inbuf[EC_PROTO2_MAX_PARAM_SIZE]; | |
1083 | } response; | |
1084 | struct ec_params_i2c_passthru *p = ¶ms.p; | |
1085 | struct ec_response_i2c_passthru *r = &response.r; | |
1086 | struct ec_params_i2c_passthru_msg *msg; | |
1087 | uint8_t *pdata, *read_ptr = NULL; | |
1088 | int read_len; | |
1089 | int size; | |
1090 | int rv; | |
1091 | int i; | |
1092 | ||
6d1a718f | 1093 | p->port = port; |
cc456bd7 SG |
1094 | |
1095 | p->num_msgs = nmsgs; | |
1096 | size = sizeof(*p) + p->num_msgs * sizeof(*msg); | |
1097 | ||
1098 | /* Create a message to write the register address and optional data */ | |
1099 | pdata = (uint8_t *)p + size; | |
1100 | ||
1101 | read_len = 0; | |
1102 | for (i = 0, msg = p->msg; i < nmsgs; i++, msg++, in++) { | |
1103 | bool is_read = in->flags & I2C_M_RD; | |
1104 | ||
1105 | msg->addr_flags = in->addr; | |
1106 | msg->len = in->len; | |
1107 | if (is_read) { | |
1108 | msg->addr_flags |= EC_I2C_FLAG_READ; | |
1109 | read_len += in->len; | |
1110 | read_ptr = in->buf; | |
1111 | if (sizeof(*r) + read_len > sizeof(response)) { | |
1112 | puts("Read length too big for buffer\n"); | |
1113 | return -1; | |
1114 | } | |
1115 | } else { | |
1116 | if (pdata - (uint8_t *)p + in->len > sizeof(params)) { | |
1117 | puts("Params too large for buffer\n"); | |
1118 | return -1; | |
1119 | } | |
1120 | memcpy(pdata, in->buf, in->len); | |
1121 | pdata += in->len; | |
1122 | } | |
1123 | } | |
1124 | ||
1125 | rv = ec_command(cdev, EC_CMD_I2C_PASSTHRU, 0, p, pdata - (uint8_t *)p, | |
1126 | r, sizeof(*r) + read_len); | |
1127 | if (rv < 0) | |
1128 | return rv; | |
1129 | ||
1130 | /* Parse response */ | |
1131 | if (r->i2c_status & EC_I2C_STATUS_ERROR) { | |
1132 | printf("Transfer failed with status=0x%x\n", r->i2c_status); | |
1133 | return -1; | |
1134 | } | |
1135 | ||
1136 | if (rv < sizeof(*r) + read_len) { | |
1137 | puts("Truncated read response\n"); | |
1138 | return -1; | |
1139 | } | |
1140 | ||
1141 | /* We only support a single read message for each transfer */ | |
1142 | if (read_len) | |
1143 | memcpy(read_ptr, r->data, read_len); | |
1144 | ||
1145 | return 0; | |
1146 | } | |
1147 | ||
84d6cbd3 SG |
1148 | UCLASS_DRIVER(cros_ec) = { |
1149 | .id = UCLASS_CROS_EC, | |
1150 | .name = "cros_ec", | |
1151 | .per_device_auto_alloc_size = sizeof(struct cros_ec_dev), | |
91195485 | 1152 | .post_bind = dm_scan_fdt_dev, |
84d6cbd3 | 1153 | }; |