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

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (c) 2011 The Chromium OS Authors. All rights reserved.
 */

/*
 * CBFS commands
 */
#include <common.h>
#include <command.h>
#include <env.h>
#include <cbfs.h>

static int do_cbfs_init(struct cmd_tbl *cmdtp, int flag, int argc,
			char *const argv[])
{
	uintptr_t end_of_rom = 0xffffffff;
	char *ep;

	if (argc > 2) {
		printf("usage: cbfsls [end of rom]>\n");
		return 0;
	}
	if (argc == 2) {
		end_of_rom = hextoul(argv[1], &ep);
		if (*ep) {
			puts("\n** Invalid end of ROM **\n");
			return 1;
		}
	}
	if (file_cbfs_init(end_of_rom)) {
		printf("%s.\n", file_cbfs_error());
		return 1;
	}
	return 0;
}

U_BOOT_CMD(
	cbfsinit,	2,	0,	do_cbfs_init,
	"initialize the cbfs driver",
	"[end of rom]\n"
	"    - Initialize the cbfs driver. The optional 'end of rom'\n"
	"      parameter specifies where the end of the ROM is that the\n"
	"      CBFS is in. It defaults to 0xFFFFFFFF\n"
);

static int do_cbfs_fsload(struct cmd_tbl *cmdtp, int flag, int argc,
			  char *const argv[])
{
	const struct cbfs_cachenode *file;
	unsigned long offset;
	unsigned long count;
	long size;

	if (argc < 3) {
		printf("usage: cbfsload <addr> <filename> [bytes]\n");
		return 1;
	}

	/* parse offset and count */
	offset = hextoul(argv[1], NULL);
	if (argc == 4)
		count = hextoul(argv[3], NULL);
	else
		count = 0;

	file = file_cbfs_find(argv[2]);
	if (!file) {
		if (cbfs_get_result() == CBFS_FILE_NOT_FOUND)
			printf("%s: %s\n", file_cbfs_error(), argv[2]);
		else
			printf("%s.\n", file_cbfs_error());
		return 1;
	}

	printf("reading %s\n", file_cbfs_name(file));

	size = file_cbfs_read(file, (void *)offset, count);

	printf("\n%ld bytes read\n", size);

	env_set_hex("filesize", size);

	return 0;
}

U_BOOT_CMD(
	cbfsload,	4,	0,	do_cbfs_fsload,
	"load binary file from a cbfs filesystem",
	"<addr> <filename> [bytes]\n"
	"    - load binary file 'filename' from the cbfs to address 'addr'\n"
);

static int do_cbfs_ls(struct cmd_tbl *cmdtp, int flag, int argc,
		      char *const argv[])
{
	const struct cbfs_cachenode *file = file_cbfs_get_first();
	int files = 0;

	if (!file) {
		printf("%s.\n", file_cbfs_error());
		return 1;
	}

	printf("     size              type  name\n");
	printf("------------------------------------------\n");
	while (file) {
		int type = file_cbfs_type(file);
		char *type_name = NULL;
		const char *filename = file_cbfs_name(file);

		printf(" %8d", file_cbfs_size(file));

		switch (type) {
		case CBFS_TYPE_BOOTBLOCK:
			type_name = "bootblock";
			break;
		case CBFS_TYPE_CBFSHEADER:
			type_name = "cbfs header";
			break;
		case CBFS_TYPE_LEGACY_STAGE:
			type_name = "stage";
			break;
		case CBFS_TYPE_PAYLOAD:
			type_name = "payload";
			break;
		case CBFS_TYPE_FIT:
			type_name = "fit";
			break;
		case CBFS_TYPE_OPTIONROM:
			type_name = "option rom";
			break;
		case CBFS_TYPE_BOOTSPLASH:
			type_name = "boot splash";
			break;
		case CBFS_TYPE_RAW:
			type_name = "raw";
			break;
		case CBFS_TYPE_VSA:
			type_name = "vsa";
			break;
		case CBFS_TYPE_MBI:
			type_name = "mbi";
			break;
		case CBFS_TYPE_MICROCODE:
			type_name = "microcode";
			break;
		case CBFS_TYPE_FSP:
			type_name = "fsp";
			break;
		case CBFS_TYPE_MRC:
			type_name = "mrc";
			break;
		case CBFS_TYPE_MMA:
			type_name = "mma";
			break;
		case CBFS_TYPE_EFI:
			type_name = "efi";
			break;
		case CBFS_TYPE_STRUCT:
			type_name = "struct";
			break;
		case CBFS_TYPE_CMOS_DEFAULT:
			type_name = "cmos default";
			break;
		case CBFS_TYPE_SPD:
			type_name = "spd";
			break;
		case CBFS_TYPE_MRC_CACHE:
			type_name = "mrc cache";
			break;
		case CBFS_TYPE_CMOS_LAYOUT:
			type_name = "cmos layout";
			break;
		case -1:
		case 0:
			type_name = "null";
			break;
		}
		if (type_name)
			printf("  %16s", type_name);
		else
			printf("  %16d", type);

		if (filename[0])
			printf("  %s\n", filename);
		else
			printf("  %s\n", "(empty)");
		file_cbfs_get_next(&file);
		files++;
	}

	printf("\n%d file(s)\n\n", files);
	return 0;
}

U_BOOT_CMD(
	cbfsls,	1,	1,	do_cbfs_ls,
	"list files",
	"    - list the files in the cbfs\n"
);

static int do_cbfs_fsinfo(struct cmd_tbl *cmdtp, int flag, int argc,
			  char *const argv[])
{
	const struct cbfs_header *header = file_cbfs_get_header();

	if (!header) {
		printf("%s.\n", file_cbfs_error());
		return 1;
	}

	printf("\n");
	printf("CBFS version: %#x\n", header->version);
	printf("ROM size: %#x\n", header->rom_size);
	printf("Boot block size: %#x\n", header->boot_block_size);
	printf("CBFS size: %#x\n",
		header->rom_size - header->boot_block_size - header->offset);
	printf("Alignment: %d\n", header->align);
	printf("Offset: %#x\n", header->offset);
	printf("\n");

	return 0;
}

U_BOOT_CMD(
	cbfsinfo,	1,	1,	do_cbfs_fsinfo,
	"print information about filesystem",
	"    - print information about the cbfs filesystem\n"
);
Commit	Line	Data
83d290c5	1	// SPDX-License-Identifier: GPL-2.0+
84cd9327 GB	2	/*
84cd9327 GB	3	* Copyright (c) 2011 The Chromium OS Authors. All rights reserved.
84cd9327 GB	4	*/
	5
	6	/*
	7	* CBFS commands
	8	*/
d678a59d	9	#include <common.h>
84cd9327	10	#include <command.h>
c7694dd4	11	#include <env.h>
84cd9327 GB	12	#include <cbfs.h>
84cd9327 GB	13
09140113	14	static int do_cbfs_init(struct cmd_tbl *cmdtp, int flag, int argc,
633fb736	15	char *const argv[])
84cd9327 GB	16	{
	17	uintptr_t end_of_rom = 0xffffffff;
	18	char *ep;
	19
	20	if (argc > 2) {
	21	printf("usage: cbfsls [end of rom]>\n");
	22	return 0;
	23	}
	24	if (argc == 2) {
7e5f460e	25	end_of_rom = hextoul(argv[1], &ep);
84cd9327 GB	26	if (*ep) {
	27	puts("\n Invalid end of ROM \n");
	28	return 1;
	29	}
	30	}
0e7b6312	31	if (file_cbfs_init(end_of_rom)) {
84cd9327 GB	32	printf("%s.\n", file_cbfs_error());
	33	return 1;
	34	}
	35	return 0;
	36	}
	37
	38	U_BOOT_CMD(
	39	cbfsinit, 2, 0, do_cbfs_init,
	40	"initialize the cbfs driver",
	41	"[end of rom]\n"
	42	" - Initialize the cbfs driver. The optional 'end of rom'\n"
	43	" parameter specifies where the end of the ROM is that the\n"
	44	" CBFS is in. It defaults to 0xFFFFFFFF\n"
	45	);
	46
09140113	47	static int do_cbfs_fsload(struct cmd_tbl *cmdtp, int flag, int argc,
633fb736	48	char *const argv[])
84cd9327 GB	49	{
	50	const struct cbfs_cachenode *file;
	51	unsigned long offset;
	52	unsigned long count;
84cd9327 GB	53	long size;
	54
	55	if (argc < 3) {
	56	printf("usage: cbfsload <addr> <filename> [bytes]\n");
	57	return 1;
	58	}
	59
	60	/* parse offset and count */
7e5f460e	61	offset = hextoul(argv[1], NULL);
84cd9327	62	if (argc == 4)
7e5f460e	63	count = hextoul(argv[3], NULL);
84cd9327 GB	64	else
	65	count = 0;
	66
	67	file = file_cbfs_find(argv[2]);
	68	if (!file) {
c7f16934	69	if (cbfs_get_result() == CBFS_FILE_NOT_FOUND)
84cd9327 GB	70	printf("%s: %s\n", file_cbfs_error(), argv[2]);
	71	else
	72	printf("%s.\n", file_cbfs_error());
	73	return 1;
	74	}
	75
	76	printf("reading %s\n", file_cbfs_name(file));
	77
	78	size = file_cbfs_read(file, (void *)offset, count);
	79
	80	printf("\n%ld bytes read\n", size);
	81
018f5303	82	env_set_hex("filesize", size);
84cd9327 GB	83
	84	return 0;
	85	}
	86
	87	U_BOOT_CMD(
	88	cbfsload, 4, 0, do_cbfs_fsload,
	89	"load binary file from a cbfs filesystem",
	90	"<addr> <filename> [bytes]\n"
	91	" - load binary file 'filename' from the cbfs to address 'addr'\n"
	92	);
	93
09140113	94	static int do_cbfs_ls(struct cmd_tbl *cmdtp, int flag, int argc,
633fb736	95	char *const argv[])
84cd9327 GB	96	{
	97	const struct cbfs_cachenode *file = file_cbfs_get_first();
	98	int files = 0;
	99
	100	if (!file) {
	101	printf("%s.\n", file_cbfs_error());
	102	return 1;
	103	}
	104
	105	printf(" size type name\n");
	106	printf("------------------------------------------\n");
	107	while (file) {
a696d768	108	int type = file_cbfs_type(file);
84cd9327 GB	109	char *type_name = NULL;
	110	const char *filename = file_cbfs_name(file);
	111
	112	printf(" %8d", file_cbfs_size(file));
	113
	114	switch (type) {
881bb9ab BM	115	case CBFS_TYPE_BOOTBLOCK:
	116	type_name = "bootblock";
	117	break;
	118	case CBFS_TYPE_CBFSHEADER:
	119	type_name = "cbfs header";
	120	break;
fe35c2f0	121	case CBFS_TYPE_LEGACY_STAGE:
84cd9327 GB	122	type_name = "stage";
	123	break;
	124	case CBFS_TYPE_PAYLOAD:
	125	type_name = "payload";
	126	break;
881bb9ab BM	127	case CBFS_TYPE_FIT:
	128	type_name = "fit";
	129	break;
84cd9327 GB	130	case CBFS_TYPE_OPTIONROM:
	131	type_name = "option rom";
	132	break;
	133	case CBFS_TYPE_BOOTSPLASH:
	134	type_name = "boot splash";
	135	break;
	136	case CBFS_TYPE_RAW:
	137	type_name = "raw";
	138	break;
	139	case CBFS_TYPE_VSA:
	140	type_name = "vsa";
	141	break;
	142	case CBFS_TYPE_MBI:
	143	type_name = "mbi";
	144	break;
	145	case CBFS_TYPE_MICROCODE:
	146	type_name = "microcode";
	147	break;
881bb9ab BM	148	case CBFS_TYPE_FSP:
	149	type_name = "fsp";
	150	break;
	151	case CBFS_TYPE_MRC:
	152	type_name = "mrc";
	153	break;
	154	case CBFS_TYPE_MMA:
	155	type_name = "mma";
	156	break;
	157	case CBFS_TYPE_EFI:
	158	type_name = "efi";
	159	break;
	160	case CBFS_TYPE_STRUCT:
	161	type_name = "struct";
	162	break;
14fdf91e	163	case CBFS_TYPE_CMOS_DEFAULT:
84cd9327 GB	164	type_name = "cmos default";
84cd9327 GB	165	break;
881bb9ab BM	166	case CBFS_TYPE_SPD:
	167	type_name = "spd";
	168	break;
	169	case CBFS_TYPE_MRC_CACHE:
	170	type_name = "mrc cache";
	171	break;
14fdf91e	172	case CBFS_TYPE_CMOS_LAYOUT:
84cd9327 GB	173	type_name = "cmos layout";
84cd9327 GB	174	break;
a696d768 SG	175	case -1:
a696d768 SG	176	case 0:
84cd9327 GB	177	type_name = "null";
	178	break;
	179	}
	180	if (type_name)
	181	printf(" %16s", type_name);
	182	else
	183	printf(" %16d", type);
	184
	185	if (filename[0])
	186	printf(" %s\n", filename);
	187	else
	188	printf(" %s\n", "(empty)");
	189	file_cbfs_get_next(&file);
	190	files++;
	191	}
	192
	193	printf("\n%d file(s)\n\n", files);
	194	return 0;
	195	}
	196
	197	U_BOOT_CMD(
	198	cbfsls, 1, 1, do_cbfs_ls,
	199	"list files",
	200	" - list the files in the cbfs\n"
	201	);
	202
09140113	203	static int do_cbfs_fsinfo(struct cmd_tbl *cmdtp, int flag, int argc,
633fb736	204	char *const argv[])
84cd9327 GB	205	{
	206	const struct cbfs_header *header = file_cbfs_get_header();
	207
	208	if (!header) {
	209	printf("%s.\n", file_cbfs_error());
	210	return 1;
	211	}
	212
	213	printf("\n");
	214	printf("CBFS version: %#x\n", header->version);
	215	printf("ROM size: %#x\n", header->rom_size);
	216	printf("Boot block size: %#x\n", header->boot_block_size);
	217	printf("CBFS size: %#x\n",
	218	header->rom_size - header->boot_block_size - header->offset);
	219	printf("Alignment: %d\n", header->align);
	220	printf("Offset: %#x\n", header->offset);
	221	printf("\n");
	222
	223	return 0;
	224	}
	225
	226	U_BOOT_CMD(
	227	cbfsinfo, 1, 1, do_cbfs_fsinfo,
	228	"print information about filesystem",
	229	" - print information about the cbfs filesystem\n"
	230	);