[J-u-boot.git] / cmd / cros_ec.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Chromium OS cros_ec driver
 *
 * Copyright (c) 2016 The Chromium OS Authors.
 * Copyright (c) 2016 National Instruments Corp
 */

#include <common.h>
#include <command.h>
#include <cros_ec.h>
#include <dm.h>
#include <flash.h>
#include <log.h>
#include <dm/device-internal.h>
#include <dm/uclass-internal.h>

/* Note: depends on enum ec_current_image */
static const char * const ec_current_image_name[] = {"unknown", "RO", "RW"};

/**
 * Decode a flash region parameter
 *
 * @param argc Number of params remaining
 * @param argv List of remaining parameters
 * @return flash region (EC_FLASH_REGION_...) or -1 on error
 */
static int cros_ec_decode_region(int argc, char *const argv[])
{
	if (argc > 0) {
		if (0 == strcmp(*argv, "rw"))
			return EC_FLASH_REGION_ACTIVE;
		else if (0 == strcmp(*argv, "ro"))
			return EC_FLASH_REGION_RO;

		debug("%s: Invalid region '%s'\n", __func__, *argv);
	} else {
		debug("%s: Missing region parameter\n", __func__);
	}

	return -1;
}

/**
 * Perform a flash read or write command
 *
 * @param dev		CROS-EC device to read/write
 * @param is_write	1 do to a write, 0 to do a read
 * @param argc		Number of arguments
 * @param argv		Arguments (2 is region, 3 is address)
 * @return 0 for ok, 1 for a usage error or -ve for ec command error
 *	(negative EC_RES_...)
 */
static int do_read_write(struct udevice *dev, int is_write, int argc,
			 char *const argv[])
{
	uint32_t offset, size = -1U, region_size;
	unsigned long addr;
	char *endp;
	int region;
	int ret;

	region = cros_ec_decode_region(argc - 2, argv + 2);
	if (region == -1)
		return 1;
	if (argc < 4)
		return 1;
	addr = hextoul(argv[3], &endp);
	if (*argv[3] == 0 || *endp != 0)
		return 1;
	if (argc > 4) {
		size = hextoul(argv[4], &endp);
		if (*argv[4] == 0 || *endp != 0)
			return 1;
	}

	ret = cros_ec_flash_offset(dev, region, &offset, &region_size);
	if (ret) {
		debug("%s: Could not read region info\n", __func__);
		return ret;
	}
	if (size == -1U)
		size = region_size;

	ret = is_write ?
		cros_ec_flash_write(dev, (uint8_t *)addr, offset, size) :
		cros_ec_flash_read(dev, (uint8_t *)addr, offset, size);
	if (ret) {
		debug("%s: Could not %s region\n", __func__,
		      is_write ? "write" : "read");
		return ret;
	}

	return 0;
}

static const char *const feat_name[64] = {
	"limited",
	"flash",
	"pwm_fan",
	"pwm_keyb",
	"lightbar",
	"led",
	"motion_sense",
	"keyb",
	"pstore",
	"port80",
	"thermal",
	"bklight_switch",
	"wifi_switch",
	"host_events",
	"gpio",
	"i2c",
	"charger",
	"battery",
	"smart_battery",
	"hang_detect",
	"pmu",
	"sub_mcu",
	"usb_pd",
	"usb_mux",
	"motion_sense_fifo",
	"vstore",
	"usbc_ss_mux_virtual",
	"rtc",
	"fingerprint",
	"touchpad",
	"rwsig",
	"device_event",
	"unified_wake_masks",
	"host_event64",
	"exec_in_ram",
	"cec",
	"motion_sense_tight_timestamps",
	"refined_tablet_mode_hysteresis",
	"efs2",
	"scp",
	"ish",
	"typec_cmd",
	"typec_require_ap_mode_entry",
	"typec_mux_require_ap_ack",
};

static int do_show_features(struct udevice *dev)
{
	u64 feat;
	int ret;
	uint i;

	ret = cros_ec_get_features(dev, &feat);
	if (ret)
		return ret;
	for (i = 0; i < ARRAY_SIZE(feat_name); i++) {
		if (feat & (1ULL << i)) {
			if (feat_name[i])
				printf("%s\n", feat_name[i]);
			else
				printf("unknown %d\n", i);
		}
	}

	return 0;
}

static const char *const switch_name[8] = {
	"lid open",
	"power button pressed",
	"write-protect disabled",
	NULL,
	"dedicated recovery",
	NULL,
	NULL,
	NULL,
};

static int do_show_switches(struct udevice *dev)
{
	uint switches;
	int ret;
	uint i;

	ret = cros_ec_get_switches(dev);
	if (ret < 0)
		return log_msg_ret("get", ret);
	switches = ret;
	for (i = 0; i < ARRAY_SIZE(switch_name); i++) {
		uint mask = 1 << i;

		if (switches & mask) {
			if (switch_name[i])
				printf("%s\n", switch_name[i]);
			else
				printf("unknown %02x\n", mask);
		}
	}

	return 0;
}

static const char *const event_name[] = {
	"lid_closed",
	"lid_open",
	"power_button",
	"ac_connected",
	"ac_disconnected",
	"battery_low",
	"battery_critical",
	"battery",
	"thermal_threshold",
	"device",
	"thermal",
	"usb_charger",
	"key_pressed",
	"interface_ready",
	"keyboard_recovery",
	"thermal_shutdown",
	"battery_shutdown",
	"throttle_start",
	"throttle_stop",
	"hang_detect",
	"hang_reboot",
	"pd_mcu",
	"battery_status",
	"panic",
	"keyboard_fastboot",
	"rtc",
	"mkbp",
	"usb_mux",
	"mode_change",
	"keyboard_recovery_hw_reinit",
	"extended",
	"invalid",
};

static int do_show_events(struct udevice *dev)
{
	u32 events;
	int ret;
	uint i;

	ret = cros_ec_get_host_events(dev, &events);
	if (ret)
		return ret;
	printf("%08x\n", events);
	for (i = 0; i < ARRAY_SIZE(event_name); i++) {
		enum host_event_code code = i + 1;
		u64 mask = EC_HOST_EVENT_MASK(code);

		if (events & mask) {
			if (event_name[i])
				printf("%s\n", event_name[i]);
			else
				printf("unknown code %#x\n", code);
		}
	}

	return 0;
}

static int do_cros_ec(struct cmd_tbl *cmdtp, int flag, int argc,
		      char *const argv[])
{
	struct udevice *dev;
	const char *cmd;
	int ret = 0;

	if (argc < 2)
		return CMD_RET_USAGE;

	cmd = argv[1];
	if (0 == strcmp("init", cmd)) {
		/* Remove any existing device */
		ret = uclass_find_device(UCLASS_CROS_EC, 0, &dev);
		if (!ret)
			device_remove(dev, DM_REMOVE_NORMAL);
		ret = uclass_get_device(UCLASS_CROS_EC, 0, &dev);
		if (ret) {
			printf("Could not init cros_ec device (err %d)\n", ret);
			return 1;
		}
		return 0;
	}

	ret = uclass_get_device(UCLASS_CROS_EC, 0, &dev);
	if (ret) {
		printf("Cannot get cros-ec device (err=%d)\n", ret);
		return 1;
	}
	if (0 == strcmp("id", cmd)) {
		char id[MSG_BYTES];

		if (cros_ec_read_id(dev, id, sizeof(id))) {
			debug("%s: Could not read KBC ID\n", __func__);
			return 1;
		}
		printf("%s\n", id);
	} else if (0 == strcmp("info", cmd)) {
		struct ec_response_mkbp_info info;

		if (cros_ec_info(dev, &info)) {
			debug("%s: Could not read KBC info\n", __func__);
			return 1;
		}
		printf("rows     = %u\n", info.rows);
		printf("cols     = %u\n", info.cols);
	} else if (!strcmp("features", cmd)) {
		ret = do_show_features(dev);

		if (ret)
			printf("Error: %d\n", ret);
	} else if (!strcmp("switches", cmd)) {
		ret = do_show_switches(dev);

		if (ret)
			printf("Error: %d\n", ret);
	} else if (0 == strcmp("curimage", cmd)) {
		enum ec_current_image image;

		if (cros_ec_read_current_image(dev, &image)) {
			debug("%s: Could not read KBC image\n", __func__);
			return 1;
		}
		printf("%d\n", image);
	} else if (0 == strcmp("hash", cmd)) {
		struct ec_response_vboot_hash hash;
		int i;

		if (cros_ec_read_hash(dev, EC_VBOOT_HASH_OFFSET_ACTIVE, &hash)) {
			debug("%s: Could not read KBC hash\n", __func__);
			return 1;
		}

		if (hash.hash_type == EC_VBOOT_HASH_TYPE_SHA256)
			printf("type:    SHA-256\n");
		else
			printf("type:    %d\n", hash.hash_type);

		printf("offset:  0x%08x\n", hash.offset);
		printf("size:    0x%08x\n", hash.size);

		printf("digest:  ");
		for (i = 0; i < hash.digest_size; i++)
			printf("%02x", hash.hash_digest[i]);
		printf("\n");
	} else if (0 == strcmp("reboot", cmd)) {
		int region;
		enum ec_reboot_cmd cmd;

		if (argc >= 3 && !strcmp(argv[2], "cold")) {
			cmd = EC_REBOOT_COLD;
		} else {
			region = cros_ec_decode_region(argc - 2, argv + 2);
			if (region == EC_FLASH_REGION_RO)
				cmd = EC_REBOOT_JUMP_RO;
			else if (region == EC_FLASH_REGION_ACTIVE)
				cmd = EC_REBOOT_JUMP_RW;
			else
				return CMD_RET_USAGE;
		}

		if (cros_ec_reboot(dev, cmd, 0)) {
			debug("%s: Could not reboot KBC\n", __func__);
			return 1;
		}
	} else if (0 == strcmp("events", cmd)) {
		ret = do_show_events(dev);

		if (ret)
			printf("Error: %d\n", ret);
	} else if (0 == strcmp("clrevents", cmd)) {
		uint32_t events = 0x7fffffff;

		if (argc >= 3)
			events = simple_strtol(argv[2], NULL, 0);

		if (cros_ec_clear_host_events(dev, events)) {
			debug("%s: Could not clear host events\n", __func__);
			return 1;
		}
	} else if (0 == strcmp("read", cmd)) {
		ret = do_read_write(dev, 0, argc, argv);
		if (ret > 0)
			return CMD_RET_USAGE;
	} else if (0 == strcmp("write", cmd)) {
		ret = do_read_write(dev, 1, argc, argv);
		if (ret > 0)
			return CMD_RET_USAGE;
	} else if (0 == strcmp("erase", cmd)) {
		int region = cros_ec_decode_region(argc - 2, argv + 2);
		uint32_t offset, size;

		if (region == -1)
			return CMD_RET_USAGE;
		if (cros_ec_flash_offset(dev, region, &offset, &size)) {
			debug("%s: Could not read region info\n", __func__);
			ret = -1;
		} else {
			ret = cros_ec_flash_erase(dev, offset, size);
			if (ret) {
				debug("%s: Could not erase region\n",
				      __func__);
			}
		}
	} else if (0 == strcmp("regioninfo", cmd)) {
		int region = cros_ec_decode_region(argc - 2, argv + 2);
		uint32_t offset, size;

		if (region == -1)
			return CMD_RET_USAGE;
		ret = cros_ec_flash_offset(dev, region, &offset, &size);
		if (ret) {
			debug("%s: Could not read region info\n", __func__);
		} else {
			printf("Region: %s\n", region == EC_FLASH_REGION_RO ?
					"RO" : "RW");
			printf("Offset: %x\n", offset);
			printf("Size:   %x\n", size);
		}
	} else if (0 == strcmp("flashinfo", cmd)) {
		struct ec_response_flash_info p;

		ret = cros_ec_read_flashinfo(dev, &p);
		if (!ret) {
			printf("Flash size:         %u\n", p.flash_size);
			printf("Write block size:   %u\n", p.write_block_size);
			printf("Erase block size:   %u\n", p.erase_block_size);
		}
	} else if (0 == strcmp("vbnvcontext", cmd)) {
		uint8_t block[EC_VBNV_BLOCK_SIZE];
		char buf[3];
		int i, len;
		unsigned long result;

		if (argc <= 2) {
			ret = cros_ec_read_nvdata(dev, block,
						  EC_VBNV_BLOCK_SIZE);
			if (!ret) {
				printf("vbnv_block: ");
				for (i = 0; i < EC_VBNV_BLOCK_SIZE; i++)
					printf("%02x", block[i]);
				putc('\n');
			}
		} else {
			/*
			 * TODO(clchiou): Move this to a utility function as
			 * cmd_spi might want to call it.
			 */
			memset(block, 0, EC_VBNV_BLOCK_SIZE);
			len = strlen(argv[2]);
			buf[2] = '\0';
			for (i = 0; i < EC_VBNV_BLOCK_SIZE; i++) {
				if (i * 2 >= len)
					break;
				buf[0] = argv[2][i * 2];
				if (i * 2 + 1 >= len)
					buf[1] = '0';
				else
					buf[1] = argv[2][i * 2 + 1];
				strict_strtoul(buf, 16, &result);
				block[i] = result;
			}
			ret = cros_ec_write_nvdata(dev, block,
						   EC_VBNV_BLOCK_SIZE);
		}
		if (ret) {
			debug("%s: Could not %s VbNvContext\n", __func__,
			      argc <= 2 ?  "read" : "write");
		}
	} else if (0 == strcmp("test", cmd)) {
		int result = cros_ec_test(dev);

		if (result)
			printf("Test failed with error %d\n", result);
		else
			puts("Test passed\n");
	} else if (0 == strcmp("version", cmd)) {
		struct ec_response_get_version *p;
		char *build_string;

		ret = cros_ec_read_version(dev, &p);
		if (!ret) {
			/* Print versions */
			printf("RO version:    %1.*s\n",
			       (int)sizeof(p->version_string_ro),
			       p->version_string_ro);
			printf("RW version:    %1.*s\n",
			       (int)sizeof(p->version_string_rw),
			       p->version_string_rw);
			printf("Firmware copy: %s\n",
			       (p->current_image <
			       ARRAY_SIZE(ec_current_image_name) ?
			       ec_current_image_name[p->current_image] :
			       "?"));
			ret = cros_ec_read_build_info(dev, &build_string);
			if (!ret)
				printf("Build info:    %s\n", build_string);
		}
	} else if (0 == strcmp("ldo", cmd)) {
		uint8_t index, state;
		char *endp;

		if (argc < 3)
			return CMD_RET_USAGE;
		index = dectoul(argv[2], &endp);
		if (*argv[2] == 0 || *endp != 0)
			return CMD_RET_USAGE;
		if (argc > 3) {
			state = dectoul(argv[3], &endp);
			if (*argv[3] == 0 || *endp != 0)
				return CMD_RET_USAGE;
			ret = cros_ec_set_ldo(dev, index, state);
		} else {
			ret = cros_ec_get_ldo(dev, index, &state);
			if (!ret) {
				printf("LDO%d: %s\n", index,
				       state == EC_LDO_STATE_ON ?
				       "on" : "off");
			}
		}

		if (ret) {
			debug("%s: Could not access LDO%d\n", __func__, index);
			return ret;
		}
	} else if (!strcmp("sku", cmd)) {
		ret = cros_ec_get_sku_id(dev);

		if (ret >= 0) {
			printf("%d\n", ret);
			ret = 0;
		} else {
			printf("Error: %d\n", ret);
		}
	} else {
		return CMD_RET_USAGE;
	}

	if (ret < 0) {
		printf("Error: CROS-EC command failed (error %d)\n", ret);
		ret = 1;
	}

	return ret;
}

U_BOOT_CMD(
	crosec,	6,	1,	do_cros_ec,
	"CROS-EC utility command",
	"init                Re-init CROS-EC (done on startup automatically)\n"
	"crosec id                  Read CROS-EC ID\n"
	"crosec info                Read CROS-EC info\n"
	"crosec features            Read CROS-EC features\n"
	"crosec switches            Read CROS-EC switches\n"
	"crosec curimage            Read CROS-EC current image\n"
	"crosec hash                Read CROS-EC hash\n"
	"crosec reboot [rw | ro | cold]  Reboot CROS-EC\n"
	"crosec events              Read CROS-EC host events\n"
	"crosec eventsb             Read CROS-EC host events_b\n"
	"crosec clrevents [mask]    Clear CROS-EC host events\n"
	"crosec regioninfo <ro|rw>  Read image info\n"
	"crosec flashinfo           Read flash info\n"
	"crosec erase <ro|rw>       Erase EC image\n"
	"crosec read <ro|rw> <addr> [<size>]   Read EC image\n"
	"crosec write <ro|rw> <addr> [<size>]  Write EC image\n"
	"crosec vbnvcontext [hexstring]        Read [write] VbNvContext from EC\n"
	"crosec ldo <idx> [<state>] Switch/Read LDO state\n"
	"crosec sku                 Read board SKU ID\n"
	"crosec test                run tests on cros_ec\n"
	"crosec version             Read CROS-EC version"
);
Commit	Line	Data
83d290c5	1	// SPDX-License-Identifier: GPL-2.0+
bfeba017 MF	2	/*
	3	* Chromium OS cros_ec driver
	4	*
	5	* Copyright (c) 2016 The Chromium OS Authors.
	6	* Copyright (c) 2016 National Instruments Corp
bfeba017 MF	7	*/
	8
	9	#include <common.h>
	10	#include <command.h>
	11	#include <cros_ec.h>
	12	#include <dm.h>
b79fdc76	13	#include <flash.h>
f7ae49fc	14	#include <log.h>
bfeba017 MF	15	#include <dm/device-internal.h>
	16	#include <dm/uclass-internal.h>
	17
	18	/* Note: depends on enum ec_current_image */
	19	static const char * const ec_current_image_name[] = {"unknown", "RO", "RW"};
	20
a2558e87 MF	21	/**
	22	* Decode a flash region parameter
	23	*
	24	* @param argc Number of params remaining
	25	* @param argv List of remaining parameters
	26	* @return flash region (EC_FLASH_REGION_...) or -1 on error
	27	*/
09140113	28	static int cros_ec_decode_region(int argc, char *const argv[])
a2558e87 MF	29	{
	30	if (argc > 0) {
	31	if (0 == strcmp(*argv, "rw"))
6f1c0430	32	return EC_FLASH_REGION_ACTIVE;
a2558e87 MF	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
bfeba017 MF	44	/**
	45	* Perform a flash read or write command
	46	*
	47	* @param dev CROS-EC device to read/write
	48	* @param is_write 1 do to a write, 0 to do a read
	49	* @param argc Number of arguments
	50	* @param argv Arguments (2 is region, 3 is address)
	51	* @return 0 for ok, 1 for a usage error or -ve for ec command error
	52	* (negative EC_RES_...)
	53	*/
6322a7b6	54	static int do_read_write(struct udevice *dev, int is_write, int argc,
09140113	55	char *const argv[])
bfeba017 MF	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;
7e5f460e	68	addr = hextoul(argv[3], &endp);
bfeba017 MF	69	if (argv[3] == 0 \|\| endp != 0)
	70	return 1;
	71	if (argc > 4) {
7e5f460e	72	size = hextoul(argv[4], &endp);
bfeba017 MF	73	if (argv[4] == 0 \|\| endp != 0)
	74	return 1;
	75	}
	76
	77	ret = cros_ec_flash_offset(dev, region, &offset, &region_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
8aec32f6 SG	97	static const char *const feat_name[64] = {
	98	"limited",
	99	"flash",
	100	"pwm_fan",
	101	"pwm_keyb",
	102	"lightbar",
	103	"led",
	104	"motion_sense",
	105	"keyb",
	106	"pstore",
	107	"port80",
	108	"thermal",
	109	"bklight_switch",
	110	"wifi_switch",
	111	"host_events",
	112	"gpio",
	113	"i2c",
	114	"charger",
	115	"battery",
	116	"smart_battery",
	117	"hang_detect",
	118	"pmu",
	119	"sub_mcu",
	120	"usb_pd",
	121	"usb_mux",
	122	"motion_sense_fifo",
	123	"vstore",
	124	"usbc_ss_mux_virtual",
	125	"rtc",
	126	"fingerprint",
	127	"touchpad",
	128	"rwsig",
	129	"device_event",
	130	"unified_wake_masks",
	131	"host_event64",
	132	"exec_in_ram",
	133	"cec",
	134	"motion_sense_tight_timestamps",
	135	"refined_tablet_mode_hysteresis",
	136	"efs2",
	137	"scp",
	138	"ish",
	139	"typec_cmd",
	140	"typec_require_ap_mode_entry",
	141	"typec_mux_require_ap_ack",
	142	};
	143
	144	static int do_show_features(struct udevice *dev)
	145	{
	146	u64 feat;
	147	int ret;
	148	uint i;
	149
	150	ret = cros_ec_get_features(dev, &feat);
	151	if (ret)
	152	return ret;
	153	for (i = 0; i < ARRAY_SIZE(feat_name); i++) {
	154	if (feat & (1ULL << i)) {
	155	if (feat_name[i])
	156	printf("%s\n", feat_name[i]);
	157	else
	158	printf("unknown %d\n", i);
	159	}
	160	}
161
162	return 0;
163	}
164
3a6c994f SG	165	static const char *const switch_name[8] = {
	166	"lid open",
	167	"power button pressed",
	168	"write-protect disabled",
	169	NULL,
	170	"dedicated recovery",
	171	NULL,
	172	NULL,
	173	NULL,
	174	};
	175
	176	static int do_show_switches(struct udevice *dev)
	177	{
	178	uint switches;
	179	int ret;
	180	uint i;
	181
	182	ret = cros_ec_get_switches(dev);
	183	if (ret < 0)
	184	return log_msg_ret("get", ret);
	185	switches = ret;
	186	for (i = 0; i < ARRAY_SIZE(switch_name); i++) {
	187	uint mask = 1 << i;
	188
	189	if (switches & mask) {
	190	if (switch_name[i])
	191	printf("%s\n", switch_name[i]);
	192	else
	193	printf("unknown %02x\n", mask);
	194	}
	195	}
	196
	197	return 0;
	198	}
	199
3ae33829 SG	200	static const char *const event_name[] = {
	201	"lid_closed",
	202	"lid_open",
	203	"power_button",
	204	"ac_connected",
	205	"ac_disconnected",
	206	"battery_low",
	207	"battery_critical",
	208	"battery",
	209	"thermal_threshold",
	210	"device",
	211	"thermal",
	212	"usb_charger",
	213	"key_pressed",
	214	"interface_ready",
	215	"keyboard_recovery",
	216	"thermal_shutdown",
	217	"battery_shutdown",
	218	"throttle_start",
	219	"throttle_stop",
	220	"hang_detect",
	221	"hang_reboot",
	222	"pd_mcu",
	223	"battery_status",
	224	"panic",
	225	"keyboard_fastboot",
	226	"rtc",
	227	"mkbp",
	228	"usb_mux",
	229	"mode_change",
	230	"keyboard_recovery_hw_reinit",
	231	"extended",
	232	"invalid",
	233	};
	234
	235	static int do_show_events(struct udevice *dev)
	236	{
	237	u32 events;
	238	int ret;
	239	uint i;
	240
	241	ret = cros_ec_get_host_events(dev, &events);
	242	if (ret)
	243	return ret;
	244	printf("%08x\n", events);
	245	for (i = 0; i < ARRAY_SIZE(event_name); i++) {
	246	enum host_event_code code = i + 1;
	247	u64 mask = EC_HOST_EVENT_MASK(code);
	248
	249	if (events & mask) {
	250	if (event_name[i])
	251	printf("%s\n", event_name[i]);
	252	else
	253	printf("unknown code %#x\n", code);
	254	}
	255	}
	256
	257	return 0;
	258	}
	259
09140113 SG	260	static int do_cros_ec(struct cmd_tbl *cmdtp, int flag, int argc,
09140113 SG	261	char *const argv[])
bfeba017	262	{
6322a7b6	263	struct udevice *dev;
bfeba017 MF	264	const char *cmd;
	265	int ret = 0;
	266
	267	if (argc < 2)
	268	return CMD_RET_USAGE;
	269
	270	cmd = argv[1];
	271	if (0 == strcmp("init", cmd)) {
	272	/* Remove any existing device */
6322a7b6	273	ret = uclass_find_device(UCLASS_CROS_EC, 0, &dev);
bfeba017	274	if (!ret)
6322a7b6 SG	275	device_remove(dev, DM_REMOVE_NORMAL);
6322a7b6 SG	276	ret = uclass_get_device(UCLASS_CROS_EC, 0, &dev);
bfeba017 MF	277	if (ret) {
	278	printf("Could not init cros_ec device (err %d)\n", ret);
	279	return 1;
	280	}
	281	return 0;
	282	}
	283
6322a7b6	284	ret = uclass_get_device(UCLASS_CROS_EC, 0, &dev);
bfeba017 MF	285	if (ret) {
	286	printf("Cannot get cros-ec device (err=%d)\n", ret);
	287	return 1;
	288	}
bfeba017 MF	289	if (0 == strcmp("id", cmd)) {
	290	char id[MSG_BYTES];
	291
	292	if (cros_ec_read_id(dev, id, sizeof(id))) {
	293	debug("%s: Could not read KBC ID\n", __func__);
	294	return 1;
	295	}
	296	printf("%s\n", id);
	297	} else if (0 == strcmp("info", cmd)) {
	298	struct ec_response_mkbp_info info;
	299
	300	if (cros_ec_info(dev, &info)) {
	301	debug("%s: Could not read KBC info\n", __func__);
	302	return 1;
	303	}
	304	printf("rows = %u\n", info.rows);
	305	printf("cols = %u\n", info.cols);
8aec32f6 SG	306	} else if (!strcmp("features", cmd)) {
	307	ret = do_show_features(dev);
	308
3a6c994f SG	309	if (ret)
	310	printf("Error: %d\n", ret);
	311	} else if (!strcmp("switches", cmd)) {
	312	ret = do_show_switches(dev);
	313
8aec32f6 SG	314	if (ret)
8aec32f6 SG	315	printf("Error: %d\n", ret);
bfeba017 MF	316	} else if (0 == strcmp("curimage", cmd)) {
	317	enum ec_current_image image;
	318
	319	if (cros_ec_read_current_image(dev, &image)) {
	320	debug("%s: Could not read KBC image\n", __func__);
	321	return 1;
	322	}
	323	printf("%d\n", image);
	324	} else if (0 == strcmp("hash", cmd)) {
	325	struct ec_response_vboot_hash hash;
	326	int i;
	327
a12ef7e2	328	if (cros_ec_read_hash(dev, EC_VBOOT_HASH_OFFSET_ACTIVE, &hash)) {
bfeba017 MF	329	debug("%s: Could not read KBC hash\n", __func__);
	330	return 1;
	331	}
	332
	333	if (hash.hash_type == EC_VBOOT_HASH_TYPE_SHA256)
	334	printf("type: SHA-256\n");
	335	else
	336	printf("type: %d\n", hash.hash_type);
	337
	338	printf("offset: 0x%08x\n", hash.offset);
	339	printf("size: 0x%08x\n", hash.size);
	340
	341	printf("digest: ");
	342	for (i = 0; i < hash.digest_size; i++)
	343	printf("%02x", hash.hash_digest[i]);
	344	printf("\n");
	345	} else if (0 == strcmp("reboot", cmd)) {
	346	int region;
	347	enum ec_reboot_cmd cmd;
	348
	349	if (argc >= 3 && !strcmp(argv[2], "cold")) {
	350	cmd = EC_REBOOT_COLD;
	351	} else {
	352	region = cros_ec_decode_region(argc - 2, argv + 2);
	353	if (region == EC_FLASH_REGION_RO)
	354	cmd = EC_REBOOT_JUMP_RO;
6f1c0430	355	else if (region == EC_FLASH_REGION_ACTIVE)
bfeba017 MF	356	cmd = EC_REBOOT_JUMP_RW;
	357	else
	358	return CMD_RET_USAGE;
	359	}
	360
	361	if (cros_ec_reboot(dev, cmd, 0)) {
	362	debug("%s: Could not reboot KBC\n", __func__);
	363	return 1;
	364	}
	365	} else if (0 == strcmp("events", cmd)) {
3ae33829	366	ret = do_show_events(dev);
bfeba017	367
3ae33829 SG	368	if (ret)
3ae33829 SG	369	printf("Error: %d\n", ret);
bfeba017 MF	370	} else if (0 == strcmp("clrevents", cmd)) {
	371	uint32_t events = 0x7fffffff;
	372
	373	if (argc >= 3)
	374	events = simple_strtol(argv[2], NULL, 0);
	375
	376	if (cros_ec_clear_host_events(dev, events)) {
	377	debug("%s: Could not clear host events\n", __func__);
	378	return 1;
	379	}
	380	} else if (0 == strcmp("read", cmd)) {
	381	ret = do_read_write(dev, 0, argc, argv);
	382	if (ret > 0)
	383	return CMD_RET_USAGE;
	384	} else if (0 == strcmp("write", cmd)) {
	385	ret = do_read_write(dev, 1, argc, argv);
	386	if (ret > 0)
	387	return CMD_RET_USAGE;
	388	} else if (0 == strcmp("erase", cmd)) {
	389	int region = cros_ec_decode_region(argc - 2, argv + 2);
	390	uint32_t offset, size;
	391
	392	if (region == -1)
	393	return CMD_RET_USAGE;
	394	if (cros_ec_flash_offset(dev, region, &offset, &size)) {
	395	debug("%s: Could not read region info\n", __func__);
	396	ret = -1;
	397	} else {
	398	ret = cros_ec_flash_erase(dev, offset, size);
	399	if (ret) {
	400	debug("%s: Could not erase region\n",
	401	__func__);
	402	}
	403	}
	404	} else if (0 == strcmp("regioninfo", cmd)) {
	405	int region = cros_ec_decode_region(argc - 2, argv + 2);
	406	uint32_t offset, size;
	407
	408	if (region == -1)
	409	return CMD_RET_USAGE;
	410	ret = cros_ec_flash_offset(dev, region, &offset, &size);
	411	if (ret) {
	412	debug("%s: Could not read region info\n", __func__);
	413	} else {
	414	printf("Region: %s\n", region == EC_FLASH_REGION_RO ?
	415	"RO" : "RW");
	416	printf("Offset: %x\n", offset);
	417	printf("Size: %x\n", size);
	418	}
	419	} else if (0 == strcmp("flashinfo", cmd)) {
	420	struct ec_response_flash_info p;
	421
	422	ret = cros_ec_read_flashinfo(dev, &p);
	423	if (!ret) {
	424	printf("Flash size: %u\n", p.flash_size);
	425	printf("Write block size: %u\n", p.write_block_size);
	426	printf("Erase block size: %u\n", p.erase_block_size);
	427	}
	428	} else if (0 == strcmp("vbnvcontext", cmd)) {
	429	uint8_t block[EC_VBNV_BLOCK_SIZE];
	430	char buf[3];
	431	int i, len;
	432	unsigned long result;
	433
434	if (argc <= 2) {
6322a7b6 SG	435	ret = cros_ec_read_nvdata(dev, block,
6322a7b6 SG	436	EC_VBNV_BLOCK_SIZE);
bfeba017 MF	437	if (!ret) {
	438	printf("vbnv_block: ");
	439	for (i = 0; i < EC_VBNV_BLOCK_SIZE; i++)
	440	printf("%02x", block[i]);
	441	putc('\n');
	442	}
	443	} else {
	444	/*
	445	* TODO(clchiou): Move this to a utility function as
	446	* cmd_spi might want to call it.
	447	*/
	448	memset(block, 0, EC_VBNV_BLOCK_SIZE);
	449	len = strlen(argv[2]);
	450	buf[2] = '\0';
	451	for (i = 0; i < EC_VBNV_BLOCK_SIZE; i++) {
	452	if (i * 2 >= len)
	453	break;
	454	buf[0] = argv[2][i * 2];
	455	if (i * 2 + 1 >= len)
	456	buf[1] = '0';
	457	else
	458	buf[1] = argv[2][i * 2 + 1];
	459	strict_strtoul(buf, 16, &result);
	460	block[i] = result;
	461	}
6322a7b6 SG	462	ret = cros_ec_write_nvdata(dev, block,
6322a7b6 SG	463	EC_VBNV_BLOCK_SIZE);
bfeba017 MF	464	}
	465	if (ret) {
	466	debug("%s: Could not %s VbNvContext\n", __func__,
	467	argc <= 2 ? "read" : "write");
	468	}
	469	} else if (0 == strcmp("test", cmd)) {
	470	int result = cros_ec_test(dev);
	471
	472	if (result)
	473	printf("Test failed with error %d\n", result);
	474	else
	475	puts("Test passed\n");
	476	} else if (0 == strcmp("version", cmd)) {
	477	struct ec_response_get_version *p;
	478	char *build_string;
	479
	480	ret = cros_ec_read_version(dev, &p);
	481	if (!ret) {
	482	/* Print versions */
	483	printf("RO version: %1.*s\n",
	484	(int)sizeof(p->version_string_ro),
	485	p->version_string_ro);
	486	printf("RW version: %1.*s\n",
	487	(int)sizeof(p->version_string_rw),
	488	p->version_string_rw);
	489	printf("Firmware copy: %s\n",
	490	(p->current_image <
	491	ARRAY_SIZE(ec_current_image_name) ?
	492	ec_current_image_name[p->current_image] :
	493	"?"));
	494	ret = cros_ec_read_build_info(dev, &build_string);
	495	if (!ret)
	496	printf("Build info: %s\n", build_string);
	497	}
	498	} else if (0 == strcmp("ldo", cmd)) {
	499	uint8_t index, state;
	500	char *endp;
	501
	502	if (argc < 3)
	503	return CMD_RET_USAGE;
0b1284eb	504	index = dectoul(argv[2], &endp);
bfeba017 MF	505	if (argv[2] == 0 \|\| endp != 0)
	506	return CMD_RET_USAGE;
	507	if (argc > 3) {
0b1284eb	508	state = dectoul(argv[3], &endp);
bfeba017 MF	509	if (argv[3] == 0 \|\| endp != 0)
bfeba017 MF	510	return CMD_RET_USAGE;
6322a7b6	511	ret = cros_ec_set_ldo(dev, index, state);
bfeba017	512	} else {
6322a7b6	513	ret = cros_ec_get_ldo(dev, index, &state);
bfeba017 MF	514	if (!ret) {
	515	printf("LDO%d: %s\n", index,
	516	state == EC_LDO_STATE_ON ?
	517	"on" : "off");
	518	}
	519	}
	520
	521	if (ret) {
	522	debug("%s: Could not access LDO%d\n", __func__, index);
	523	return ret;
	524	}
7791df57 SG	525	} else if (!strcmp("sku", cmd)) {
	526	ret = cros_ec_get_sku_id(dev);
	527
	528	if (ret >= 0) {
	529	printf("%d\n", ret);
	530	ret = 0;
	531	} else {
	532	printf("Error: %d\n", ret);
	533	}
bfeba017 MF	534	} else {
	535	return CMD_RET_USAGE;
	536	}
	537
	538	if (ret < 0) {
	539	printf("Error: CROS-EC command failed (error %d)\n", ret);
	540	ret = 1;
	541	}
	542
	543	return ret;
	544	}
	545
	546	U_BOOT_CMD(
	547	crosec, 6, 1, do_cros_ec,
	548	"CROS-EC utility command",
	549	"init Re-init CROS-EC (done on startup automatically)\n"
	550	"crosec id Read CROS-EC ID\n"
	551	"crosec info Read CROS-EC info\n"
8aec32f6	552	"crosec features Read CROS-EC features\n"
3a6c994f	553	"crosec switches Read CROS-EC switches\n"
bfeba017 MF	554	"crosec curimage Read CROS-EC current image\n"
	555	"crosec hash Read CROS-EC hash\n"
	556	"crosec reboot [rw \| ro \| cold] Reboot CROS-EC\n"
	557	"crosec events Read CROS-EC host events\n"
3ae33829	558	"crosec eventsb Read CROS-EC host events_b\n"
bfeba017 MF	559	"crosec clrevents [mask] Clear CROS-EC host events\n"
	560	"crosec regioninfo <ro\|rw> Read image info\n"
	561	"crosec flashinfo Read flash info\n"
	562	"crosec erase <ro\|rw> Erase EC image\n"
	563	"crosec read <ro\|rw> <addr> [<size>] Read EC image\n"
	564	"crosec write <ro\|rw> <addr> [<size>] Write EC image\n"
	565	"crosec vbnvcontext [hexstring] Read [write] VbNvContext from EC\n"
	566	"crosec ldo <idx> [<state>] Switch/Read LDO state\n"
7791df57	567	"crosec sku Read board SKU ID\n"
bfeba017 MF	568	"crosec test run tests on cros_ec\n"
	569	"crosec version Read CROS-EC version"
	570	);