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