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

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (C) 2019 Eugeniu Rosca <[email protected]>
 *
 * Command to read/modify/write Android BCB fields
 */

#include <android_bootloader_message.h>
#include <bcb.h>
#include <command.h>
#include <display_options.h>
#include <log.h>
#include <part.h>
#include <malloc.h>
#include <memalign.h>
#include <vsprintf.h>
#include <linux/err.h>

enum bcb_cmd {
	BCB_CMD_LOAD,
	BCB_CMD_FIELD_SET,
	BCB_CMD_FIELD_CLEAR,
	BCB_CMD_FIELD_TEST,
	BCB_CMD_FIELD_DUMP,
	BCB_CMD_STORE,
};

static const char * const fields[] = {
	"command",
	"status",
	"recovery",
	"stage"
};

static struct bootloader_message bcb __aligned(ARCH_DMA_MINALIGN) = { { 0 } };
static struct disk_partition partition_data;

static struct blk_desc *block;
static struct disk_partition *partition = &partition_data;

static int bcb_cmd_get(char *cmd)
{
	if (!strcmp(cmd, "load"))
		return BCB_CMD_LOAD;
	if (!strcmp(cmd, "set"))
		return BCB_CMD_FIELD_SET;
	if (!strcmp(cmd, "clear"))
		return BCB_CMD_FIELD_CLEAR;
	if (!strcmp(cmd, "test"))
		return BCB_CMD_FIELD_TEST;
	if (!strcmp(cmd, "store"))
		return BCB_CMD_STORE;
	if (!strcmp(cmd, "dump"))
		return BCB_CMD_FIELD_DUMP;
	else
		return -1;
}

static int bcb_is_misused(int argc, char *const argv[])
{
	int cmd = bcb_cmd_get(argv[0]);

	switch (cmd) {
	case BCB_CMD_LOAD:
		if (argc != 3 && argc != 4)
			goto err;
		break;
	case BCB_CMD_FIELD_SET:
		if (argc != 3)
			goto err;
		break;
	case BCB_CMD_FIELD_TEST:
		if (argc != 4)
			goto err;
		break;
	case BCB_CMD_FIELD_CLEAR:
		if (argc != 1 && argc != 2)
			goto err;
		break;
	case BCB_CMD_STORE:
		if (argc != 1)
			goto err;
		break;
	case BCB_CMD_FIELD_DUMP:
		if (argc != 2)
			goto err;
		break;
	default:
		printf("Error: 'bcb %s' not supported\n", argv[0]);
		return -1;
	}

	if (cmd != BCB_CMD_LOAD && !block) {
		printf("Error: Please, load BCB first!\n");
		return -1;
	}

	return 0;
err:
	printf("Error: Bad usage of 'bcb %s'\n", argv[0]);

	return -1;
}

static int bcb_field_get(const char *name, char **fieldp, int *sizep)
{
	if (!strcmp(name, "command")) {
		*fieldp = bcb.command;
		*sizep = sizeof(bcb.command);
	} else if (!strcmp(name, "status")) {
		*fieldp = bcb.status;
		*sizep = sizeof(bcb.status);
	} else if (!strcmp(name, "recovery")) {
		*fieldp = bcb.recovery;
		*sizep = sizeof(bcb.recovery);
	} else if (!strcmp(name, "stage")) {
		*fieldp = bcb.stage;
		*sizep = sizeof(bcb.stage);
	} else if (!strcmp(name, "reserved")) {
		*fieldp = bcb.reserved;
		*sizep = sizeof(bcb.reserved);
	} else {
		printf("Error: Unknown bcb field '%s'\n", name);
		return -1;
	}

	return 0;
}

static void __bcb_reset(void)
{
	block = NULL;
	partition = &partition_data;
	memset(&partition_data, 0, sizeof(struct disk_partition));
	memset(&bcb, 0, sizeof(struct bootloader_message));
}

static int __bcb_initialize(const char *iface, int devnum, const char *partp)
{
	char *endp;
	int part, ret;

	block = blk_get_dev(iface, devnum);
	if (!block) {
		ret = -ENODEV;
		goto err_read_fail;
	}

	/*
	 * always select the first hwpart in case another
	 * blk operation selected a different hwpart
	 */
	ret = blk_dselect_hwpart(block, 0);
	if (IS_ERR_VALUE(ret)) {
		ret = -ENODEV;
		goto err_read_fail;
	}

	part = simple_strtoul(partp, &endp, 0);
	if (*endp == '\0') {
		ret = part_get_info(block, part, partition);
		if (ret)
			goto err_read_fail;
	} else {
		part = part_get_info_by_name(block, partp, partition);
		if (part < 0) {
			ret = part;
			goto err_read_fail;
		}
	}

	return CMD_RET_SUCCESS;

err_read_fail:
	printf("Error: %s %d:%s read failed (%d)\n", iface, devnum,
	       partition->name, ret);
	__bcb_reset();
	return CMD_RET_FAILURE;
}

static int __bcb_load(void)
{
	u64 cnt;
	int ret;

	cnt = DIV_ROUND_UP(sizeof(struct bootloader_message), partition->blksz);
	if (cnt > partition->size)
		goto err_too_small;

	if (blk_dread(block, partition->start, cnt, &bcb) != cnt) {
		ret = -EIO;
		goto err_read_fail;
	}

	debug("%s: Loaded from %d %d:%s\n", __func__, block->uclass_id,
	      block->devnum, partition->name);

	return CMD_RET_SUCCESS;
err_read_fail:
	printf("Error: %d %d:%s read failed (%d)\n", block->uclass_id,
	       block->devnum, partition->name, ret);
	goto err;
err_too_small:
	printf("Error: %d %d:%s too small!", block->uclass_id,
	       block->devnum, partition->name);
err:
	__bcb_reset();
	return CMD_RET_FAILURE;
}

static int do_bcb_load(struct cmd_tbl *cmdtp, int flag, int argc,
		       char * const argv[])
{
	int ret;
	int devnum;
	char *endp;
	char *iface = "mmc";

	if (argc == 4) {
		iface = argv[1];
		argc--;
		argv++;
	}

	devnum = simple_strtoul(argv[1], &endp, 0);
	if (*endp != '\0') {
		printf("Error: Device id '%s' not a number\n", argv[1]);
		return CMD_RET_FAILURE;
	}

	ret = __bcb_initialize(iface, devnum, argv[2]);
	if (ret != CMD_RET_SUCCESS)
		return ret;

	return __bcb_load();
}

static int __bcb_set(const char *fieldp, const char *valp)
{
	int size, len;
	char *field, *str, *found, *tmp;

	if (bcb_field_get(fieldp, &field, &size))
		return CMD_RET_FAILURE;

	len = strlen(valp);
	if (len >= size) {
		printf("Error: sizeof('%s') = %d >= %d = sizeof(bcb.%s)\n",
		       valp, len, size, fieldp);
		return CMD_RET_FAILURE;
	}
	str = strdup(valp);
	if (!str) {
		printf("Error: Out of memory while strdup\n");
		return CMD_RET_FAILURE;
	}

	tmp = str;
	field[0] = '\0';
	while ((found = strsep(&tmp, ":"))) {
		if (field[0] != '\0')
			strcat(field, "\n");
		strcat(field, found);
	}
	free(str);

	return CMD_RET_SUCCESS;
}

static int do_bcb_set(struct cmd_tbl *cmdtp, int flag, int argc,
		      char * const argv[])
{
	return __bcb_set(argv[1], argv[2]);
}

static int do_bcb_clear(struct cmd_tbl *cmdtp, int flag, int argc,
			char *const argv[])
{
	int size;
	char *field;

	if (argc == 1) {
		memset(&bcb, 0, sizeof(bcb));
		return CMD_RET_SUCCESS;
	}

	if (bcb_field_get(argv[1], &field, &size))
		return CMD_RET_FAILURE;

	memset(field, 0, size);

	return CMD_RET_SUCCESS;
}

static int do_bcb_test(struct cmd_tbl *cmdtp, int flag, int argc,
		       char *const argv[])
{
	int size;
	char *field;
	char *op = argv[2];

	if (bcb_field_get(argv[1], &field, &size))
		return CMD_RET_FAILURE;

	if (*op == '=' && *(op + 1) == '\0') {
		if (!strncmp(argv[3], field, size))
			return CMD_RET_SUCCESS;
		else
			return CMD_RET_FAILURE;
	} else if (*op == '~' && *(op + 1) == '\0') {
		if (!strstr(field, argv[3]))
			return CMD_RET_FAILURE;
		else
			return CMD_RET_SUCCESS;
	} else {
		printf("Error: Unknown operator '%s'\n", op);
	}

	return CMD_RET_FAILURE;
}

static int do_bcb_dump(struct cmd_tbl *cmdtp, int flag, int argc,
		       char *const argv[])
{
	int size;
	char *field;

	if (bcb_field_get(argv[1], &field, &size))
		return CMD_RET_FAILURE;

	print_buffer((ulong)field - (ulong)&bcb, (void *)field, 1, size, 16);

	return CMD_RET_SUCCESS;
}

static int __bcb_store(void)
{
	u64 cnt;
	int ret;

	cnt = DIV_ROUND_UP(sizeof(struct bootloader_message), partition->blksz);

	if (blk_dwrite(block, partition->start, cnt, &bcb) != cnt) {
		ret = -EIO;
		goto err;
	}

	return CMD_RET_SUCCESS;
err:
	printf("Error: %d %d:%s write failed (%d)\n", block->uclass_id,
	       block->devnum, partition->name, ret);

	return CMD_RET_FAILURE;
}

static int do_bcb_store(struct cmd_tbl *cmdtp, int flag, int argc,
			char * const argv[])
{
	return __bcb_store();
}

int bcb_find_partition_and_load(const char *iface, int devnum, char *partp)
{
	int ret;

	__bcb_reset();

	ret = __bcb_initialize(iface, devnum, partp);
	if (ret != CMD_RET_SUCCESS)
		return ret;

	return __bcb_load();
}

int bcb_load(struct blk_desc *block_description, struct disk_partition *disk_partition)
{
	__bcb_reset();

	block = block_description;
	partition = disk_partition;

	return __bcb_load();
}

int bcb_set(enum bcb_field field, const char *value)
{
	if (field > BCB_FIELD_STAGE)
		return CMD_RET_FAILURE;
	return __bcb_set(fields[field], value);
}

int bcb_get(enum bcb_field field, char *value_out, size_t value_size)
{
	int size;
	char *field_value;

	if (field > BCB_FIELD_STAGE)
		return CMD_RET_FAILURE;
	if (bcb_field_get(fields[field], &field_value, &size))
		return CMD_RET_FAILURE;

	strlcpy(value_out, field_value, value_size);

	return CMD_RET_SUCCESS;
}

int bcb_store(void)
{
	return __bcb_store();
}

void bcb_reset(void)
{
	__bcb_reset();
}

static struct cmd_tbl cmd_bcb_sub[] = {
	U_BOOT_CMD_MKENT(load, CONFIG_SYS_MAXARGS, 1, do_bcb_load, "", ""),
	U_BOOT_CMD_MKENT(set, CONFIG_SYS_MAXARGS, 1, do_bcb_set, "", ""),
	U_BOOT_CMD_MKENT(clear, CONFIG_SYS_MAXARGS, 1, do_bcb_clear, "", ""),
	U_BOOT_CMD_MKENT(test, CONFIG_SYS_MAXARGS, 1, do_bcb_test, "", ""),
	U_BOOT_CMD_MKENT(dump, CONFIG_SYS_MAXARGS, 1, do_bcb_dump, "", ""),
	U_BOOT_CMD_MKENT(store, CONFIG_SYS_MAXARGS, 1, do_bcb_store, "", ""),
};

static int do_bcb(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
	struct cmd_tbl *c;

	if (argc < 2)
		return CMD_RET_USAGE;

	argc--;
	argv++;

	c = find_cmd_tbl(argv[0], cmd_bcb_sub, ARRAY_SIZE(cmd_bcb_sub));
	if (!c)
		return CMD_RET_USAGE;

	if (bcb_is_misused(argc, argv)) {
		/*
		 * We try to improve the user experience by reporting the
		 * root-cause of misusage, so don't return CMD_RET_USAGE,
		 * since the latter prints out the full-blown help text
		 */
		return CMD_RET_FAILURE;
	}

	return c->cmd(cmdtp, flag, argc, argv);
}

U_BOOT_CMD(
	bcb, CONFIG_SYS_MAXARGS, 1, do_bcb,
	"Load/set/clear/test/dump/store Android BCB fields",
	"load <interface> <dev> <part>  - load  BCB from <interface> <dev>:<part>\n"
	"load <dev> <part>              - load  BCB from mmc <dev>:<part>\n"
	"bcb set   <field> <val>        - set   BCB <field> to <val>\n"
	"bcb clear [<field>]            - clear BCB <field> or all fields\n"
	"bcb test  <field> <op> <val>   - test  BCB <field> against <val>\n"
	"bcb dump  <field>              - dump  BCB <field>\n"
	"bcb store                      - store BCB back to <interface>\n"
	"\n"
	"Legend:\n"
	"<interface> - storage device interface (virtio, mmc, etc)\n"
	"<dev>       - storage device index containing the BCB partition\n"
	"<part>      - partition index or name containing the BCB\n"
	"<field>     - one of {command,status,recovery,stage,reserved}\n"
	"<op>        - the binary operator used in 'bcb test':\n"
	"              '=' returns true if <val> matches the string stored in <field>\n"
	"              '~' returns true if <val> matches a subset of <field>'s string\n"
	"<val>       - string/text provided as input to bcb {set,test}\n"
	"              NOTE: any ':' character in <val> will be replaced by line feed\n"
	"              during 'bcb set' and used as separator by upper layers\n"
);
Commit	Line	Data
db7b7a05 ER	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* Copyright (C) 2019 Eugeniu Rosca <[email protected]>
	4	*
	5	* Command to read/modify/write Android BCB fields
	6	*/
	7
	8	#include <android_bootloader_message.h>
e74670ad	9	#include <bcb.h>
db7b7a05	10	#include <command.h>
4e4bf944	11	#include <display_options.h>
f7ae49fc	12	#include <log.h>
e6f6f9e6	13	#include <part.h>
bafdf4ca	14	#include <malloc.h>
18956cd4	15	#include <memalign.h>
03de305e	16	#include <vsprintf.h>
64a11fb8	17	#include <linux/err.h>
db7b7a05 ER	18
	19	enum bcb_cmd {
	20	BCB_CMD_LOAD,
	21	BCB_CMD_FIELD_SET,
	22	BCB_CMD_FIELD_CLEAR,
	23	BCB_CMD_FIELD_TEST,
	24	BCB_CMD_FIELD_DUMP,
	25	BCB_CMD_STORE,
	26	};
	27
dfeb4f0d DM	28	static const char * const fields[] = {
	29	"command",
	30	"status",
	31	"recovery",
	32	"stage"
	33	};
	34
18956cd4	35	static struct bootloader_message bcb __aligned(ARCH_DMA_MINALIGN) = { { 0 } };
dfeb4f0d DM	36	static struct disk_partition partition_data;
	37
	38	static struct blk_desc *block;
	39	static struct disk_partition *partition = &partition_data;
db7b7a05 ER	40
	41	static int bcb_cmd_get(char *cmd)
	42	{
739168cf	43	if (!strcmp(cmd, "load"))
db7b7a05	44	return BCB_CMD_LOAD;
739168cf	45	if (!strcmp(cmd, "set"))
db7b7a05	46	return BCB_CMD_FIELD_SET;
739168cf	47	if (!strcmp(cmd, "clear"))
db7b7a05	48	return BCB_CMD_FIELD_CLEAR;
739168cf	49	if (!strcmp(cmd, "test"))
db7b7a05	50	return BCB_CMD_FIELD_TEST;
739168cf	51	if (!strcmp(cmd, "store"))
db7b7a05	52	return BCB_CMD_STORE;
739168cf	53	if (!strcmp(cmd, "dump"))
db7b7a05 ER	54	return BCB_CMD_FIELD_DUMP;
	55	else
	56	return -1;
	57	}
	58
	59	static int bcb_is_misused(int argc, char *const argv[])
	60	{
	61	int cmd = bcb_cmd_get(argv[0]);
	62
	63	switch (cmd) {
	64	case BCB_CMD_LOAD:
a654369b DM	65	if (argc != 3 && argc != 4)
	66	goto err;
	67	break;
db7b7a05 ER	68	case BCB_CMD_FIELD_SET:
	69	if (argc != 3)
	70	goto err;
	71	break;
	72	case BCB_CMD_FIELD_TEST:
	73	if (argc != 4)
	74	goto err;
	75	break;
	76	case BCB_CMD_FIELD_CLEAR:
	77	if (argc != 1 && argc != 2)
	78	goto err;
	79	break;
	80	case BCB_CMD_STORE:
	81	if (argc != 1)
	82	goto err;
	83	break;
	84	case BCB_CMD_FIELD_DUMP:
	85	if (argc != 2)
	86	goto err;
	87	break;
	88	default:
	89	printf("Error: 'bcb %s' not supported\n", argv[0]);
	90	return -1;
	91	}
	92
dfeb4f0d	93	if (cmd != BCB_CMD_LOAD && !block) {
db7b7a05 ER	94	printf("Error: Please, load BCB first!\n");
	95	return -1;
	96	}
	97
	98	return 0;
	99	err:
	100	printf("Error: Bad usage of 'bcb %s'\n", argv[0]);
	101
	102	return -1;
	103	}
	104
dfeb4f0d	105	static int bcb_field_get(const char name, char fieldp, int sizep)
db7b7a05	106	{
739168cf	107	if (!strcmp(name, "command")) {
37f1811a ER	108	*fieldp = bcb.command;
37f1811a ER	109	*sizep = sizeof(bcb.command);
739168cf	110	} else if (!strcmp(name, "status")) {
37f1811a ER	111	*fieldp = bcb.status;
37f1811a ER	112	*sizep = sizeof(bcb.status);
739168cf	113	} else if (!strcmp(name, "recovery")) {
37f1811a ER	114	*fieldp = bcb.recovery;
37f1811a ER	115	*sizep = sizeof(bcb.recovery);
739168cf	116	} else if (!strcmp(name, "stage")) {
37f1811a ER	117	*fieldp = bcb.stage;
37f1811a ER	118	*sizep = sizeof(bcb.stage);
739168cf	119	} else if (!strcmp(name, "reserved")) {
37f1811a ER	120	*fieldp = bcb.reserved;
37f1811a ER	121	*sizep = sizeof(bcb.reserved);
db7b7a05 ER	122	} else {
	123	printf("Error: Unknown bcb field '%s'\n", name);
	124	return -1;
	125	}
	126
	127	return 0;
	128	}
	129
dfeb4f0d DM	130	static void __bcb_reset(void)
	131	{
	132	block = NULL;
	133	partition = &partition_data;
	134	memset(&partition_data, 0, sizeof(struct disk_partition));
	135	memset(&bcb, 0, sizeof(struct bootloader_message));
	136	}
	137
	138	static int __bcb_initialize(const char iface, int devnum, const char partp)
db7b7a05	139	{
db7b7a05 ER	140	char *endp;
	141	int part, ret;
	142
dfeb4f0d DM	143	block = blk_get_dev(iface, devnum);
dfeb4f0d DM	144	if (!block) {
24e85bbd	145	ret = -ENODEV;
37f1811a	146	goto err_read_fail;
24e85bbd	147	}
db7b7a05	148
64a11fb8	149	/*
a654369b	150	* always select the first hwpart in case another
64a11fb8 MK	151	* blk operation selected a different hwpart
64a11fb8 MK	152	*/
dfeb4f0d	153	ret = blk_dselect_hwpart(block, 0);
64a11fb8 MK	154	if (IS_ERR_VALUE(ret)) {
	155	ret = -ENODEV;
	156	goto err_read_fail;
	157	}
	158
24e85bbd	159	part = simple_strtoul(partp, &endp, 0);
db7b7a05	160	if (*endp == '\0') {
dfeb4f0d	161	ret = part_get_info(block, part, partition);
db7b7a05	162	if (ret)
37f1811a	163	goto err_read_fail;
db7b7a05	164	} else {
dfeb4f0d	165	part = part_get_info_by_name(block, partp, partition);
db7b7a05 ER	166	if (part < 0) {
db7b7a05 ER	167	ret = part;
37f1811a	168	goto err_read_fail;
db7b7a05 ER	169	}
	170	}
	171
dfeb4f0d DM	172	return CMD_RET_SUCCESS;
	173
	174	err_read_fail:
61faa6dd MK	175	printf("Error: %s %d:%s read failed (%d)\n", iface, devnum,
61faa6dd MK	176	partition->name, ret);
dfeb4f0d DM	177	__bcb_reset();
	178	return CMD_RET_FAILURE;
	179	}
	180
	181	static int __bcb_load(void)
	182	{
	183	u64 cnt;
	184	int ret;
	185
	186	cnt = DIV_ROUND_UP(sizeof(struct bootloader_message), partition->blksz);
	187	if (cnt > partition->size)
37f1811a	188	goto err_too_small;
db7b7a05	189
dfeb4f0d	190	if (blk_dread(block, partition->start, cnt, &bcb) != cnt) {
db7b7a05	191	ret = -EIO;
37f1811a	192	goto err_read_fail;
db7b7a05 ER	193	}
db7b7a05 ER	194
dfeb4f0d DM	195	debug("%s: Loaded from %d %d:%s\n", __func__, block->uclass_id,
dfeb4f0d DM	196	block->devnum, partition->name);
db7b7a05 ER	197
db7b7a05 ER	198	return CMD_RET_SUCCESS;
37f1811a	199	err_read_fail:
dfeb4f0d DM	200	printf("Error: %d %d:%s read failed (%d)\n", block->uclass_id,
dfeb4f0d DM	201	block->devnum, partition->name, ret);
db7b7a05	202	goto err;
37f1811a	203	err_too_small:
dfeb4f0d DM	204	printf("Error: %d %d:%s too small!", block->uclass_id,
dfeb4f0d DM	205	block->devnum, partition->name);
db7b7a05	206	err:
dfeb4f0d	207	__bcb_reset();
db7b7a05 ER	208	return CMD_RET_FAILURE;
	209	}
	210
24e85bbd ER	211	static int do_bcb_load(struct cmd_tbl *cmdtp, int flag, int argc,
	212	char * const argv[])
	213	{
dfeb4f0d	214	int ret;
a654369b	215	int devnum;
24e85bbd	216	char *endp;
a654369b DM	217	char *iface = "mmc";
	218
	219	if (argc == 4) {
	220	iface = argv[1];
	221	argc--;
	222	argv++;
	223	}
24e85bbd	224
a654369b	225	devnum = simple_strtoul(argv[1], &endp, 0);
24e85bbd ER	226	if (*endp != '\0') {
	227	printf("Error: Device id '%s' not a number\n", argv[1]);
	228	return CMD_RET_FAILURE;
	229	}
	230
dfeb4f0d DM	231	ret = __bcb_initialize(iface, devnum, argv[2]);
	232	if (ret != CMD_RET_SUCCESS)
	233	return ret;
	234
	235	return __bcb_load();
24e85bbd ER	236	}
24e85bbd ER	237
dfeb4f0d	238	static int __bcb_set(const char fieldp, const char valp)
db7b7a05 ER	239	{
db7b7a05 ER	240	int size, len;
bafdf4ca	241	char field, str, found, tmp;
db7b7a05	242
02ebe6de	243	if (bcb_field_get(fieldp, &field, &size))
db7b7a05 ER	244	return CMD_RET_FAILURE;
db7b7a05 ER	245
02ebe6de	246	len = strlen(valp);
db7b7a05 ER	247	if (len >= size) {
db7b7a05 ER	248	printf("Error: sizeof('%s') = %d >= %d = sizeof(bcb.%s)\n",
02ebe6de	249	valp, len, size, fieldp);
db7b7a05 ER	250	return CMD_RET_FAILURE;
db7b7a05 ER	251	}
bafdf4ca ER	252	str = strdup(valp);
	253	if (!str) {
	254	printf("Error: Out of memory while strdup\n");
	255	return CMD_RET_FAILURE;
	256	}
db7b7a05	257
bafdf4ca	258	tmp = str;
db7b7a05	259	field[0] = '\0';
bafdf4ca	260	while ((found = strsep(&tmp, ":"))) {
db7b7a05 ER	261	if (field[0] != '\0')
	262	strcat(field, "\n");
	263	strcat(field, found);
	264	}
bafdf4ca	265	free(str);
db7b7a05 ER	266
	267	return CMD_RET_SUCCESS;
	268	}
	269
02ebe6de ER	270	static int do_bcb_set(struct cmd_tbl *cmdtp, int flag, int argc,
	271	char * const argv[])
	272	{
	273	return __bcb_set(argv[1], argv[2]);
	274	}
	275
09140113 SG	276	static int do_bcb_clear(struct cmd_tbl *cmdtp, int flag, int argc,
09140113 SG	277	char *const argv[])
db7b7a05 ER	278	{
	279	int size;
	280	char *field;
	281
	282	if (argc == 1) {
	283	memset(&bcb, 0, sizeof(bcb));
	284	return CMD_RET_SUCCESS;
	285	}
	286
	287	if (bcb_field_get(argv[1], &field, &size))
	288	return CMD_RET_FAILURE;
	289
	290	memset(field, 0, size);
	291
	292	return CMD_RET_SUCCESS;
	293	}
	294
09140113 SG	295	static int do_bcb_test(struct cmd_tbl *cmdtp, int flag, int argc,
09140113 SG	296	char *const argv[])
db7b7a05 ER	297	{
	298	int size;
	299	char *field;
	300	char *op = argv[2];
	301
	302	if (bcb_field_get(argv[1], &field, &size))
	303	return CMD_RET_FAILURE;
	304
	305	if (op == '=' && (op + 1) == '\0') {
	306	if (!strncmp(argv[3], field, size))
	307	return CMD_RET_SUCCESS;
	308	else
	309	return CMD_RET_FAILURE;
	310	} else if (op == '~' && (op + 1) == '\0') {
	311	if (!strstr(field, argv[3]))
	312	return CMD_RET_FAILURE;
	313	else
	314	return CMD_RET_SUCCESS;
	315	} else {
	316	printf("Error: Unknown operator '%s'\n", op);
	317	}
	318
	319	return CMD_RET_FAILURE;
	320	}
	321
09140113 SG	322	static int do_bcb_dump(struct cmd_tbl *cmdtp, int flag, int argc,
09140113 SG	323	char *const argv[])
db7b7a05 ER	324	{
	325	int size;
	326	char *field;
	327
	328	if (bcb_field_get(argv[1], &field, &size))
	329	return CMD_RET_FAILURE;
	330
	331	print_buffer((ulong)field - (ulong)&bcb, (void *)field, 1, size, 16);
	332
	333	return CMD_RET_SUCCESS;
	334	}
	335
e2ffb3be	336	static int __bcb_store(void)
db7b7a05	337	{
db7b7a05 ER	338	u64 cnt;
	339	int ret;
	340
dfeb4f0d	341	cnt = DIV_ROUND_UP(sizeof(struct bootloader_message), partition->blksz);
db7b7a05	342
dfeb4f0d	343	if (blk_dwrite(block, partition->start, cnt, &bcb) != cnt) {
db7b7a05 ER	344	ret = -EIO;
	345	goto err;
	346	}
	347
	348	return CMD_RET_SUCCESS;
	349	err:
dfeb4f0d DM	350	printf("Error: %d %d:%s write failed (%d)\n", block->uclass_id,
dfeb4f0d DM	351	block->devnum, partition->name, ret);
db7b7a05 ER	352
	353	return CMD_RET_FAILURE;
	354	}
	355
e2ffb3be ER	356	static int do_bcb_store(struct cmd_tbl *cmdtp, int flag, int argc,
	357	char * const argv[])
	358	{
	359	return __bcb_store();
	360	}
	361
dfeb4f0d	362	int bcb_find_partition_and_load(const char iface, int devnum, char partp)
e74670ad ER	363	{
	364	int ret;
	365
dfeb4f0d	366	__bcb_reset();
e74670ad	367
dfeb4f0d	368	ret = __bcb_initialize(iface, devnum, partp);
e74670ad ER	369	if (ret != CMD_RET_SUCCESS)
	370	return ret;
	371
dfeb4f0d DM	372	return __bcb_load();
dfeb4f0d DM	373	}
e74670ad	374
dfeb4f0d DM	375	int bcb_load(struct blk_desc block_description, struct disk_partition disk_partition)
	376	{
	377	__bcb_reset();
	378
	379	block = block_description;
	380	partition = disk_partition;
	381
	382	return __bcb_load();
	383	}
	384
	385	int bcb_set(enum bcb_field field, const char *value)
	386	{
	387	if (field > BCB_FIELD_STAGE)
	388	return CMD_RET_FAILURE;
	389	return __bcb_set(fields[field], value);
	390	}
	391
	392	int bcb_get(enum bcb_field field, char *value_out, size_t value_size)
	393	{
	394	int size;
	395	char *field_value;
	396
	397	if (field > BCB_FIELD_STAGE)
	398	return CMD_RET_FAILURE;
	399	if (bcb_field_get(fields[field], &field_value, &size))
	400	return CMD_RET_FAILURE;
	401
	402	strlcpy(value_out, field_value, value_size);
	403
	404	return CMD_RET_SUCCESS;
	405	}
	406
	407	int bcb_store(void)
	408	{
	409	return __bcb_store();
	410	}
	411
	412	void bcb_reset(void)
	413	{
	414	__bcb_reset();
e74670ad ER	415	}
e74670ad ER	416
09140113	417	static struct cmd_tbl cmd_bcb_sub[] = {
db7b7a05 ER	418	U_BOOT_CMD_MKENT(load, CONFIG_SYS_MAXARGS, 1, do_bcb_load, "", ""),
	419	U_BOOT_CMD_MKENT(set, CONFIG_SYS_MAXARGS, 1, do_bcb_set, "", ""),
	420	U_BOOT_CMD_MKENT(clear, CONFIG_SYS_MAXARGS, 1, do_bcb_clear, "", ""),
	421	U_BOOT_CMD_MKENT(test, CONFIG_SYS_MAXARGS, 1, do_bcb_test, "", ""),
	422	U_BOOT_CMD_MKENT(dump, CONFIG_SYS_MAXARGS, 1, do_bcb_dump, "", ""),
	423	U_BOOT_CMD_MKENT(store, CONFIG_SYS_MAXARGS, 1, do_bcb_store, "", ""),
	424	};
	425
09140113	426	static int do_bcb(struct cmd_tbl cmdtp, int flag, int argc, char const argv[])
db7b7a05	427	{
09140113	428	struct cmd_tbl *c;
db7b7a05 ER	429
	430	if (argc < 2)
	431	return CMD_RET_USAGE;
	432
	433	argc--;
	434	argv++;
	435
	436	c = find_cmd_tbl(argv[0], cmd_bcb_sub, ARRAY_SIZE(cmd_bcb_sub));
	437	if (!c)
	438	return CMD_RET_USAGE;
	439
	440	if (bcb_is_misused(argc, argv)) {
37f1811a ER	441	/*
37f1811a ER	442	* We try to improve the user experience by reporting the
db7b7a05 ER	443	* root-cause of misusage, so don't return CMD_RET_USAGE,
	444	* since the latter prints out the full-blown help text
	445	*/
	446	return CMD_RET_FAILURE;
	447	}
	448
	449	return c->cmd(cmdtp, flag, argc, argv);
	450	}
	451
	452	U_BOOT_CMD(
	453	bcb, CONFIG_SYS_MAXARGS, 1, do_bcb,
	454	"Load/set/clear/test/dump/store Android BCB fields",
a654369b DM	455	"load <interface> <dev> <part> - load BCB from <interface> <dev>:<part>\n"
	456	"load <dev> <part> - load BCB from mmc <dev>:<part>\n"
	457	"bcb set <field> <val> - set BCB <field> to <val>\n"
	458	"bcb clear [<field>] - clear BCB <field> or all fields\n"
	459	"bcb test <field> <op> <val> - test BCB <field> against <val>\n"
	460	"bcb dump <field> - dump BCB <field>\n"
	461	"bcb store - store BCB back to <interface>\n"
db7b7a05 ER	462	"\n"
db7b7a05 ER	463	"Legend:\n"
a654369b DM	464	"<interface> - storage device interface (virtio, mmc, etc)\n"
	465	"<dev> - storage device index containing the BCB partition\n"
	466	"<part> - partition index or name containing the BCB\n"
	467	"<field> - one of {command,status,recovery,stage,reserved}\n"
	468	"<op> - the binary operator used in 'bcb test':\n"
	469	" '=' returns true if <val> matches the string stored in <field>\n"
	470	" '~' returns true if <val> matches a subset of <field>'s string\n"
	471	"<val> - string/text provided as input to bcb {set,test}\n"
	472	" NOTE: any ':' character in <val> will be replaced by line feed\n"
	473	" during 'bcb set' and used as separator by upper layers\n"
db7b7a05	474	);