1
2
3
4
5
6
7
8
9#include <common.h>
10#include <command.h>
11#include <cros_ec.h>
12#include <dm.h>
13#include <flash.h>
14#include <log.h>
15#include <dm/device-internal.h>
16#include <dm/uclass-internal.h>
17
18
19static const char * const ec_current_image_name[] = {"unknown", "RO", "RW"};
20
21
22
23
24
25
26
27
28static int cros_ec_decode_region(int argc, char *const argv[])
29{
30 if (argc > 0) {
31 if (0 == strcmp(*argv, "rw"))
32 return EC_FLASH_REGION_ACTIVE;
33 else if (0 == strcmp(*argv, "ro"))
34 return EC_FLASH_REGION_RO;
35
36 debug("%s: Invalid region '%s'\n", __func__, *argv);
37 } else {
38 debug("%s: Missing region parameter\n", __func__);
39 }
40
41 return -1;
42}
43
44
45
46
47
48
49
50
51
52
53
54static int do_read_write(struct udevice *dev, int is_write, int argc,
55 char *const argv[])
56{
57 uint32_t offset, size = -1U, region_size;
58 unsigned long addr;
59 char *endp;
60 int region;
61 int ret;
62
63 region = cros_ec_decode_region(argc - 2, argv + 2);
64 if (region == -1)
65 return 1;
66 if (argc < 4)
67 return 1;
68 addr = simple_strtoul(argv[3], &endp, 16);
69 if (*argv[3] == 0 || *endp != 0)
70 return 1;
71 if (argc > 4) {
72 size = simple_strtoul(argv[4], &endp, 16);
73 if (*argv[4] == 0 || *endp != 0)
74 return 1;
75 }
76
77 ret = cros_ec_flash_offset(dev, region, &offset, ®ion_size);
78 if (ret) {
79 debug("%s: Could not read region info\n", __func__);
80 return ret;
81 }
82 if (size == -1U)
83 size = region_size;
84
85 ret = is_write ?
86 cros_ec_flash_write(dev, (uint8_t *)addr, offset, size) :
87 cros_ec_flash_read(dev, (uint8_t *)addr, offset, size);
88 if (ret) {
89 debug("%s: Could not %s region\n", __func__,
90 is_write ? "write" : "read");
91 return ret;
92 }
93
94 return 0;
95}
96
97static int do_cros_ec(struct cmd_tbl *cmdtp, int flag, int argc,
98 char *const argv[])
99{
100 struct udevice *dev;
101 const char *cmd;
102 int ret = 0;
103
104 if (argc < 2)
105 return CMD_RET_USAGE;
106
107 cmd = argv[1];
108 if (0 == strcmp("init", cmd)) {
109
110 ret = uclass_find_device(UCLASS_CROS_EC, 0, &dev);
111 if (!ret)
112 device_remove(dev, DM_REMOVE_NORMAL);
113 ret = uclass_get_device(UCLASS_CROS_EC, 0, &dev);
114 if (ret) {
115 printf("Could not init cros_ec device (err %d)\n", ret);
116 return 1;
117 }
118 return 0;
119 }
120
121 ret = uclass_get_device(UCLASS_CROS_EC, 0, &dev);
122 if (ret) {
123 printf("Cannot get cros-ec device (err=%d)\n", ret);
124 return 1;
125 }
126 if (0 == strcmp("id", cmd)) {
127 char id[MSG_BYTES];
128
129 if (cros_ec_read_id(dev, id, sizeof(id))) {
130 debug("%s: Could not read KBC ID\n", __func__);
131 return 1;
132 }
133 printf("%s\n", id);
134 } else if (0 == strcmp("info", cmd)) {
135 struct ec_response_mkbp_info info;
136
137 if (cros_ec_info(dev, &info)) {
138 debug("%s: Could not read KBC info\n", __func__);
139 return 1;
140 }
141 printf("rows = %u\n", info.rows);
142 printf("cols = %u\n", info.cols);
143 } else if (0 == strcmp("curimage", cmd)) {
144 enum ec_current_image image;
145
146 if (cros_ec_read_current_image(dev, &image)) {
147 debug("%s: Could not read KBC image\n", __func__);
148 return 1;
149 }
150 printf("%d\n", image);
151 } else if (0 == strcmp("hash", cmd)) {
152 struct ec_response_vboot_hash hash;
153 int i;
154
155 if (cros_ec_read_hash(dev, EC_VBOOT_HASH_OFFSET_ACTIVE, &hash)) {
156 debug("%s: Could not read KBC hash\n", __func__);
157 return 1;
158 }
159
160 if (hash.hash_type == EC_VBOOT_HASH_TYPE_SHA256)
161 printf("type: SHA-256\n");
162 else
163 printf("type: %d\n", hash.hash_type);
164
165 printf("offset: 0x%08x\n", hash.offset);
166 printf("size: 0x%08x\n", hash.size);
167
168 printf("digest: ");
169 for (i = 0; i < hash.digest_size; i++)
170 printf("%02x", hash.hash_digest[i]);
171 printf("\n");
172 } else if (0 == strcmp("reboot", cmd)) {
173 int region;
174 enum ec_reboot_cmd cmd;
175
176 if (argc >= 3 && !strcmp(argv[2], "cold")) {
177 cmd = EC_REBOOT_COLD;
178 } else {
179 region = cros_ec_decode_region(argc - 2, argv + 2);
180 if (region == EC_FLASH_REGION_RO)
181 cmd = EC_REBOOT_JUMP_RO;
182 else if (region == EC_FLASH_REGION_ACTIVE)
183 cmd = EC_REBOOT_JUMP_RW;
184 else
185 return CMD_RET_USAGE;
186 }
187
188 if (cros_ec_reboot(dev, cmd, 0)) {
189 debug("%s: Could not reboot KBC\n", __func__);
190 return 1;
191 }
192 } else if (0 == strcmp("events", cmd)) {
193 uint32_t events;
194
195 if (cros_ec_get_host_events(dev, &events)) {
196 debug("%s: Could not read host events\n", __func__);
197 return 1;
198 }
199 printf("0x%08x\n", events);
200 } else if (0 == strcmp("clrevents", cmd)) {
201 uint32_t events = 0x7fffffff;
202
203 if (argc >= 3)
204 events = simple_strtol(argv[2], NULL, 0);
205
206 if (cros_ec_clear_host_events(dev, events)) {
207 debug("%s: Could not clear host events\n", __func__);
208 return 1;
209 }
210 } else if (0 == strcmp("read", cmd)) {
211 ret = do_read_write(dev, 0, argc, argv);
212 if (ret > 0)
213 return CMD_RET_USAGE;
214 } else if (0 == strcmp("write", cmd)) {
215 ret = do_read_write(dev, 1, argc, argv);
216 if (ret > 0)
217 return CMD_RET_USAGE;
218 } else if (0 == strcmp("erase", cmd)) {
219 int region = cros_ec_decode_region(argc - 2, argv + 2);
220 uint32_t offset, size;
221
222 if (region == -1)
223 return CMD_RET_USAGE;
224 if (cros_ec_flash_offset(dev, region, &offset, &size)) {
225 debug("%s: Could not read region info\n", __func__);
226 ret = -1;
227 } else {
228 ret = cros_ec_flash_erase(dev, offset, size);
229 if (ret) {
230 debug("%s: Could not erase region\n",
231 __func__);
232 }
233 }
234 } else if (0 == strcmp("regioninfo", cmd)) {
235 int region = cros_ec_decode_region(argc - 2, argv + 2);
236 uint32_t offset, size;
237
238 if (region == -1)
239 return CMD_RET_USAGE;
240 ret = cros_ec_flash_offset(dev, region, &offset, &size);
241 if (ret) {
242 debug("%s: Could not read region info\n", __func__);
243 } else {
244 printf("Region: %s\n", region == EC_FLASH_REGION_RO ?
245 "RO" : "RW");
246 printf("Offset: %x\n", offset);
247 printf("Size: %x\n", size);
248 }
249 } else if (0 == strcmp("flashinfo", cmd)) {
250 struct ec_response_flash_info p;
251
252 ret = cros_ec_read_flashinfo(dev, &p);
253 if (!ret) {
254 printf("Flash size: %u\n", p.flash_size);
255 printf("Write block size: %u\n", p.write_block_size);
256 printf("Erase block size: %u\n", p.erase_block_size);
257 }
258 } else if (0 == strcmp("vbnvcontext", cmd)) {
259 uint8_t block[EC_VBNV_BLOCK_SIZE];
260 char buf[3];
261 int i, len;
262 unsigned long result;
263
264 if (argc <= 2) {
265 ret = cros_ec_read_nvdata(dev, block,
266 EC_VBNV_BLOCK_SIZE);
267 if (!ret) {
268 printf("vbnv_block: ");
269 for (i = 0; i < EC_VBNV_BLOCK_SIZE; i++)
270 printf("%02x", block[i]);
271 putc('\n');
272 }
273 } else {
274
275
276
277
278 memset(block, 0, EC_VBNV_BLOCK_SIZE);
279 len = strlen(argv[2]);
280 buf[2] = '\0';
281 for (i = 0; i < EC_VBNV_BLOCK_SIZE; i++) {
282 if (i * 2 >= len)
283 break;
284 buf[0] = argv[2][i * 2];
285 if (i * 2 + 1 >= len)
286 buf[1] = '0';
287 else
288 buf[1] = argv[2][i * 2 + 1];
289 strict_strtoul(buf, 16, &result);
290 block[i] = result;
291 }
292 ret = cros_ec_write_nvdata(dev, block,
293 EC_VBNV_BLOCK_SIZE);
294 }
295 if (ret) {
296 debug("%s: Could not %s VbNvContext\n", __func__,
297 argc <= 2 ? "read" : "write");
298 }
299 } else if (0 == strcmp("test", cmd)) {
300 int result = cros_ec_test(dev);
301
302 if (result)
303 printf("Test failed with error %d\n", result);
304 else
305 puts("Test passed\n");
306 } else if (0 == strcmp("version", cmd)) {
307 struct ec_response_get_version *p;
308 char *build_string;
309
310 ret = cros_ec_read_version(dev, &p);
311 if (!ret) {
312
313 printf("RO version: %1.*s\n",
314 (int)sizeof(p->version_string_ro),
315 p->version_string_ro);
316 printf("RW version: %1.*s\n",
317 (int)sizeof(p->version_string_rw),
318 p->version_string_rw);
319 printf("Firmware copy: %s\n",
320 (p->current_image <
321 ARRAY_SIZE(ec_current_image_name) ?
322 ec_current_image_name[p->current_image] :
323 "?"));
324 ret = cros_ec_read_build_info(dev, &build_string);
325 if (!ret)
326 printf("Build info: %s\n", build_string);
327 }
328 } else if (0 == strcmp("ldo", cmd)) {
329 uint8_t index, state;
330 char *endp;
331
332 if (argc < 3)
333 return CMD_RET_USAGE;
334 index = simple_strtoul(argv[2], &endp, 10);
335 if (*argv[2] == 0 || *endp != 0)
336 return CMD_RET_USAGE;
337 if (argc > 3) {
338 state = simple_strtoul(argv[3], &endp, 10);
339 if (*argv[3] == 0 || *endp != 0)
340 return CMD_RET_USAGE;
341 ret = cros_ec_set_ldo(dev, index, state);
342 } else {
343 ret = cros_ec_get_ldo(dev, index, &state);
344 if (!ret) {
345 printf("LDO%d: %s\n", index,
346 state == EC_LDO_STATE_ON ?
347 "on" : "off");
348 }
349 }
350
351 if (ret) {
352 debug("%s: Could not access LDO%d\n", __func__, index);
353 return ret;
354 }
355 } else {
356 return CMD_RET_USAGE;
357 }
358
359 if (ret < 0) {
360 printf("Error: CROS-EC command failed (error %d)\n", ret);
361 ret = 1;
362 }
363
364 return ret;
365}
366
367U_BOOT_CMD(
368 crosec, 6, 1, do_cros_ec,
369 "CROS-EC utility command",
370 "init Re-init CROS-EC (done on startup automatically)\n"
371 "crosec id Read CROS-EC ID\n"
372 "crosec info Read CROS-EC info\n"
373 "crosec curimage Read CROS-EC current image\n"
374 "crosec hash Read CROS-EC hash\n"
375 "crosec reboot [rw | ro | cold] Reboot CROS-EC\n"
376 "crosec events Read CROS-EC host events\n"
377 "crosec clrevents [mask] Clear CROS-EC host events\n"
378 "crosec regioninfo <ro|rw> Read image info\n"
379 "crosec flashinfo Read flash info\n"
380 "crosec erase <ro|rw> Erase EC image\n"
381 "crosec read <ro|rw> <addr> [<size>] Read EC image\n"
382 "crosec write <ro|rw> <addr> [<size>] Write EC image\n"
383 "crosec vbnvcontext [hexstring] Read [write] VbNvContext from EC\n"
384 "crosec ldo <idx> [<state>] Switch/Read LDO state\n"
385 "crosec test run tests on cros_ec\n"
386 "crosec version Read CROS-EC version"
387);
388
