[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 <common.h>
#include <display_options.h>
#include <log.h>
#include <part.h>
#include <malloc.h>
#include <memalign.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 int bcb_dev = -1;
static int bcb_part = -1;
static struct bootloader_message bcb __aligned(ARCH_DMA_MINALIGN) = { { 0 } };

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:
	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 && (bcb_dev < 0 || bcb_part < 0)) {
		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(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 int __bcb_load(int devnum, const char *partp)
{
	struct blk_desc *desc;
	struct disk_partition info;
	u64 cnt;
	char *endp;
	int part, ret;

	desc = blk_get_devnum_by_uclass_id(UCLASS_MMC, devnum);
	if (!desc) {
		ret = -ENODEV;
		goto err_read_fail;
	}

	/*
	 * always select the USER mmc hwpart in case another
	 * blk operation selected a different hwpart
	 */
	ret = blk_dselect_hwpart(desc, 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(desc, part, &info);
		if (ret)
			goto err_read_fail;
	} else {
		part = part_get_info_by_name(desc, partp, &info);
		if (part < 0) {
			ret = part;
			goto err_read_fail;
		}
	}

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

	if (blk_dread(desc, info.start, cnt, &bcb) != cnt) {
		ret = -EIO;
		goto err_read_fail;
	}

	bcb_dev = desc->devnum;
	bcb_part = part;
	debug("%s: Loaded from mmc %d:%d\n", __func__, bcb_dev, bcb_part);

	return CMD_RET_SUCCESS;
err_read_fail:
	printf("Error: mmc %d:%s read failed (%d)\n", devnum, partp, ret);
	goto err;
err_too_small:
	printf("Error: mmc %d:%s too small!", devnum, partp);
	goto err;
err:
	bcb_dev = -1;
	bcb_part = -1;

	return CMD_RET_FAILURE;
}

static int do_bcb_load(struct cmd_tbl *cmdtp, int flag, int argc,
		       char * const argv[])
{
	char *endp;
	int 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;
	}

	return __bcb_load(devnum, argv[2]);
}

static int __bcb_set(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)
{
	struct blk_desc *desc;
	struct disk_partition info;
	u64 cnt;
	int ret;

	desc = blk_get_devnum_by_uclass_id(UCLASS_MMC, bcb_dev);
	if (!desc) {
		ret = -ENODEV;
		goto err;
	}

	ret = part_get_info(desc, bcb_part, &info);
	if (ret)
		goto err;

	cnt = DIV_ROUND_UP(sizeof(struct bootloader_message), info.blksz);

	if (blk_dwrite(desc, info.start, cnt, &bcb) != cnt) {
		ret = -EIO;
		goto err;
	}

	return CMD_RET_SUCCESS;
err:
	printf("Error: mmc %d:%d write failed (%d)\n", bcb_dev, bcb_part, 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_write_reboot_reason(int devnum, char *partp, const char *reasonp)
{
	int ret;

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

	ret = __bcb_set("command", reasonp);
	if (ret != CMD_RET_SUCCESS)
		return ret;

	ret = __bcb_store();
	if (ret != CMD_RET_SUCCESS)
		return ret;

	return 0;
}

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