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

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (C) 2019 Eugeniu Rosca <rosca.eugeniu@gmail.com>
 *
 * Command to read/modify/write Android BCB fields
 */

#include <android_bootloader_message.h>
#include <command.h>
#include <common.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 = { { 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 do_bcb_load(cmd_tbl_t *cmdtp, int flag, int argc,
		       char * const argv[])
{
	struct blk_desc *desc;
	disk_partition_t info;
	u64 cnt;
	char *endp;
	int part, ret;

	ret = blk_get_device_by_str("mmc", argv[1], &desc);
	if (ret < 0)
		goto err_read_fail;

	part = simple_strtoul(argv[2], &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, argv[2], &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 %s:%s read failed (%d)\n", argv[1], argv[2], ret);
	goto err;
err_too_small:
	printf("Error: mmc %s:%s too small!", argv[1], argv[2]);
	goto err;
err:
	bcb_dev = -1;
	bcb_part = -1;

	return CMD_RET_FAILURE;
}

static int do_bcb_set(cmd_tbl_t *cmdtp, int flag, int argc,
		      char * const argv[])
{
	int size, len;
	char *field, *str, *found;

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

	len = strlen(argv[2]);
	if (len >= size) {
		printf("Error: sizeof('%s') = %d >= %d = sizeof(bcb.%s)\n",
		       argv[2], len, size, argv[1]);
		return CMD_RET_FAILURE;
	}
	str = argv[2];

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

	return CMD_RET_SUCCESS;
}

static int do_bcb_clear(cmd_tbl_t *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(cmd_tbl_t *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(cmd_tbl_t *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 do_bcb_store(cmd_tbl_t *cmdtp, int flag, int argc,
			char * const argv[])
{
	struct blk_desc *desc;
	disk_partition_t info;
	u64 cnt;
	int ret;

	desc = blk_get_devnum_by_type(IF_TYPE_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 cmd_tbl_t 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(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
{
	cmd_tbl_t *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 <rosca.eugeniu@gmail.com>
	4	*
	5	* Command to read/modify/write Android BCB fields
	6	*/
	7
	8	#include <android_bootloader_message.h>
	9	#include <command.h>
	10	#include <common.h>
	11
	12	enum bcb_cmd {
	13	BCB_CMD_LOAD,
	14	BCB_CMD_FIELD_SET,
	15	BCB_CMD_FIELD_CLEAR,
	16	BCB_CMD_FIELD_TEST,
	17	BCB_CMD_FIELD_DUMP,
	18	BCB_CMD_STORE,
	19	};
	20
	21	static int bcb_dev = -1;
	22	static int bcb_part = -1;
	23	static struct bootloader_message bcb = { { 0 } };
	24
	25	static int bcb_cmd_get(char *cmd)
	26	{
739168cf	27	if (!strcmp(cmd, "load"))
db7b7a05	28	return BCB_CMD_LOAD;
739168cf	29	if (!strcmp(cmd, "set"))
db7b7a05	30	return BCB_CMD_FIELD_SET;
739168cf	31	if (!strcmp(cmd, "clear"))
db7b7a05	32	return BCB_CMD_FIELD_CLEAR;
739168cf	33	if (!strcmp(cmd, "test"))
db7b7a05	34	return BCB_CMD_FIELD_TEST;
739168cf	35	if (!strcmp(cmd, "store"))
db7b7a05	36	return BCB_CMD_STORE;
739168cf	37	if (!strcmp(cmd, "dump"))
db7b7a05 ER	38	return BCB_CMD_FIELD_DUMP;
	39	else
	40	return -1;
	41	}
	42
	43	static int bcb_is_misused(int argc, char *const argv[])
	44	{
	45	int cmd = bcb_cmd_get(argv[0]);
	46
	47	switch (cmd) {
	48	case BCB_CMD_LOAD:
db7b7a05 ER	49	case BCB_CMD_FIELD_SET:
	50	if (argc != 3)
	51	goto err;
	52	break;
	53	case BCB_CMD_FIELD_TEST:
	54	if (argc != 4)
	55	goto err;
	56	break;
	57	case BCB_CMD_FIELD_CLEAR:
	58	if (argc != 1 && argc != 2)
	59	goto err;
	60	break;
	61	case BCB_CMD_STORE:
	62	if (argc != 1)
	63	goto err;
	64	break;
	65	case BCB_CMD_FIELD_DUMP:
	66	if (argc != 2)
	67	goto err;
	68	break;
	69	default:
	70	printf("Error: 'bcb %s' not supported\n", argv[0]);
	71	return -1;
	72	}
	73
	74	if (cmd != BCB_CMD_LOAD && (bcb_dev < 0 \|\| bcb_part < 0)) {
	75	printf("Error: Please, load BCB first!\n");
	76	return -1;
	77	}
	78
	79	return 0;
	80	err:
	81	printf("Error: Bad usage of 'bcb %s'\n", argv[0]);
	82
	83	return -1;
	84	}
	85
37f1811a	86	static int bcb_field_get(char name, char fieldp, int sizep)
db7b7a05	87	{
739168cf	88	if (!strcmp(name, "command")) {
37f1811a ER	89	*fieldp = bcb.command;
37f1811a ER	90	*sizep = sizeof(bcb.command);
739168cf	91	} else if (!strcmp(name, "status")) {
37f1811a ER	92	*fieldp = bcb.status;
37f1811a ER	93	*sizep = sizeof(bcb.status);
739168cf	94	} else if (!strcmp(name, "recovery")) {
37f1811a ER	95	*fieldp = bcb.recovery;
37f1811a ER	96	*sizep = sizeof(bcb.recovery);
739168cf	97	} else if (!strcmp(name, "stage")) {
37f1811a ER	98	*fieldp = bcb.stage;
37f1811a ER	99	*sizep = sizeof(bcb.stage);
739168cf	100	} else if (!strcmp(name, "reserved")) {
37f1811a ER	101	*fieldp = bcb.reserved;
37f1811a ER	102	*sizep = sizeof(bcb.reserved);
db7b7a05 ER	103	} else {
	104	printf("Error: Unknown bcb field '%s'\n", name);
	105	return -1;
	106	}
	107
	108	return 0;
	109	}
	110
37f1811a ER	111	static int do_bcb_load(cmd_tbl_t *cmdtp, int flag, int argc,
37f1811a ER	112	char * const argv[])
db7b7a05 ER	113	{
	114	struct blk_desc *desc;
	115	disk_partition_t info;
	116	u64 cnt;
	117	char *endp;
	118	int part, ret;
	119
	120	ret = blk_get_device_by_str("mmc", argv[1], &desc);
	121	if (ret < 0)
37f1811a	122	goto err_read_fail;
db7b7a05 ER	123
	124	part = simple_strtoul(argv[2], &endp, 0);
	125	if (*endp == '\0') {
	126	ret = part_get_info(desc, part, &info);
	127	if (ret)
37f1811a	128	goto err_read_fail;
db7b7a05 ER	129	} else {
	130	part = part_get_info_by_name(desc, argv[2], &info);
	131	if (part < 0) {
	132	ret = part;
37f1811a	133	goto err_read_fail;
db7b7a05 ER	134	}
	135	}
	136
	137	cnt = DIV_ROUND_UP(sizeof(struct bootloader_message), info.blksz);
	138	if (cnt > info.size)
37f1811a	139	goto err_too_small;
db7b7a05 ER	140
	141	if (blk_dread(desc, info.start, cnt, &bcb) != cnt) {
	142	ret = -EIO;
37f1811a	143	goto err_read_fail;
db7b7a05 ER	144	}
	145
	146	bcb_dev = desc->devnum;
	147	bcb_part = part;
	148	debug("%s: Loaded from mmc %d:%d\n", __func__, bcb_dev, bcb_part);
	149
	150	return CMD_RET_SUCCESS;
37f1811a	151	err_read_fail:
db7b7a05 ER	152	printf("Error: mmc %s:%s read failed (%d)\n", argv[1], argv[2], ret);
db7b7a05 ER	153	goto err;
37f1811a	154	err_too_small:
db7b7a05 ER	155	printf("Error: mmc %s:%s too small!", argv[1], argv[2]);
	156	goto err;
	157	err:
	158	bcb_dev = -1;
	159	bcb_part = -1;
	160
	161	return CMD_RET_FAILURE;
	162	}
	163
	164	static int do_bcb_set(cmd_tbl_t *cmdtp, int flag, int argc,
	165	char * const argv[])
	166	{
	167	int size, len;
	168	char field, str, *found;
	169
	170	if (bcb_field_get(argv[1], &field, &size))
	171	return CMD_RET_FAILURE;
	172
	173	len = strlen(argv[2]);
	174	if (len >= size) {
	175	printf("Error: sizeof('%s') = %d >= %d = sizeof(bcb.%s)\n",
	176	argv[2], len, size, argv[1]);
	177	return CMD_RET_FAILURE;
	178	}
	179	str = argv[2];
	180
	181	field[0] = '\0';
	182	while ((found = strsep(&str, ":"))) {
	183	if (field[0] != '\0')
	184	strcat(field, "\n");
	185	strcat(field, found);
	186	}
	187
	188	return CMD_RET_SUCCESS;
	189	}
	190
	191	static int do_bcb_clear(cmd_tbl_t *cmdtp, int flag, int argc,
	192	char * const argv[])
	193	{
	194	int size;
	195	char *field;
	196
	197	if (argc == 1) {
	198	memset(&bcb, 0, sizeof(bcb));
	199	return CMD_RET_SUCCESS;
	200	}
	201
	202	if (bcb_field_get(argv[1], &field, &size))
	203	return CMD_RET_FAILURE;
	204
	205	memset(field, 0, size);
	206
	207	return CMD_RET_SUCCESS;
	208	}
	209
	210	static int do_bcb_test(cmd_tbl_t *cmdtp, int flag, int argc,
	211	char * const argv[])
	212	{
	213	int size;
	214	char *field;
	215	char *op = argv[2];
	216
	217	if (bcb_field_get(argv[1], &field, &size))
	218	return CMD_RET_FAILURE;
219
220	if (op == '=' && (op + 1) == '\0') {
221	if (!strncmp(argv[3], field, size))
222	return CMD_RET_SUCCESS;
223	else
224	return CMD_RET_FAILURE;
225	} else if (op == '~' && (op + 1) == '\0') {
226	if (!strstr(field, argv[3]))
227	return CMD_RET_FAILURE;
228	else
229	return CMD_RET_SUCCESS;
230	} else {
231	printf("Error: Unknown operator '%s'\n", op);
232	}
233
234	return CMD_RET_FAILURE;
235	}
236
237	static int do_bcb_dump(cmd_tbl_t *cmdtp, int flag, int argc,
238	char * const argv[])
239	{
240	int size;
241	char *field;
242
243	if (bcb_field_get(argv[1], &field, &size))
244	return CMD_RET_FAILURE;
245
246	print_buffer((ulong)field - (ulong)&bcb, (void *)field, 1, size, 16);
247
248	return CMD_RET_SUCCESS;
249	}
250
251	static int do_bcb_store(cmd_tbl_t *cmdtp, int flag, int argc,
252	char * const argv[])
253	{
254	struct blk_desc *desc;
255	disk_partition_t info;
256	u64 cnt;
257	int ret;
258
259	desc = blk_get_devnum_by_type(IF_TYPE_MMC, bcb_dev);
260	if (!desc) {
261	ret = -ENODEV;
262	goto err;
263	}
264
265	ret = part_get_info(desc, bcb_part, &info);
266	if (ret)
267	goto err;
268
269	cnt = DIV_ROUND_UP(sizeof(struct bootloader_message), info.blksz);
270
271	if (blk_dwrite(desc, info.start, cnt, &bcb) != cnt) {
272	ret = -EIO;
273	goto err;
274	}
275
276	return CMD_RET_SUCCESS;
277	err:
278	printf("Error: mmc %d:%d write failed (%d)\n", bcb_dev, bcb_part, ret);
279
280	return CMD_RET_FAILURE;
281	}
282
283	static cmd_tbl_t cmd_bcb_sub[] = {
284	U_BOOT_CMD_MKENT(load, CONFIG_SYS_MAXARGS, 1, do_bcb_load, "", ""),
285	U_BOOT_CMD_MKENT(set, CONFIG_SYS_MAXARGS, 1, do_bcb_set, "", ""),
286	U_BOOT_CMD_MKENT(clear, CONFIG_SYS_MAXARGS, 1, do_bcb_clear, "", ""),
287	U_BOOT_CMD_MKENT(test, CONFIG_SYS_MAXARGS, 1, do_bcb_test, "", ""),
288	U_BOOT_CMD_MKENT(dump, CONFIG_SYS_MAXARGS, 1, do_bcb_dump, "", ""),
289	U_BOOT_CMD_MKENT(store, CONFIG_SYS_MAXARGS, 1, do_bcb_store, "", ""),
290	};
291
292	static int do_bcb(cmd_tbl_t cmdtp, int flag, int argc, char const argv[])
293	{
294	cmd_tbl_t *c;
295
296	if (argc < 2)
297	return CMD_RET_USAGE;
298
299	argc--;
300	argv++;
301
302	c = find_cmd_tbl(argv[0], cmd_bcb_sub, ARRAY_SIZE(cmd_bcb_sub));
303	if (!c)
304	return CMD_RET_USAGE;
305
306	if (bcb_is_misused(argc, argv)) {
37f1811a ER	307	/*
37f1811a ER	308	* We try to improve the user experience by reporting the
db7b7a05 ER	309	* root-cause of misusage, so don't return CMD_RET_USAGE,
	310	* since the latter prints out the full-blown help text
	311	*/
	312	return CMD_RET_FAILURE;
	313	}
	314
	315	return c->cmd(cmdtp, flag, argc, argv);
	316	}
	317
	318	U_BOOT_CMD(
	319	bcb, CONFIG_SYS_MAXARGS, 1, do_bcb,
	320	"Load/set/clear/test/dump/store Android BCB fields",
	321	"load <dev> <part> - load BCB from mmc <dev>:<part>\n"
	322	"bcb set <field> <val> - set BCB <field> to <val>\n"
	323	"bcb clear [<field>] - clear BCB <field> or all fields\n"
	324	"bcb test <field> <op> <val> - test BCB <field> against <val>\n"
	325	"bcb dump <field> - dump BCB <field>\n"
	326	"bcb store - store BCB back to mmc\n"
	327	"\n"
	328	"Legend:\n"
	329	"<dev> - MMC device index containing the BCB partition\n"
	330	"<part> - MMC partition index or name containing the BCB\n"
	331	"<field> - one of {command,status,recovery,stage,reserved}\n"
	332	"<op> - the binary operator used in 'bcb test':\n"
	333	" '=' returns true if <val> matches the string stored in <field>\n"
	334	" '~' returns true if <val> matches a subset of <field>'s string\n"
	335	"<val> - string/text provided as input to bcb {set,test}\n"
	336	" NOTE: any ':' character in <val> will be replaced by line feed\n"
	337	" during 'bcb set' and used as separator by upper layers\n"
	338	);