[people/ms/u-boot.git] / cmd / cbfs.c

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

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

static int do_cbfs_init(cmd_tbl_t *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 = (int)simple_strtoul(argv[1], &ep, 16);
		if (*ep) {
			puts("\n** Invalid end of ROM **\n");
			return 1;
		}
	}
	file_cbfs_init(end_of_rom);
	if (file_cbfs_result != CBFS_SUCCESS) {
		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(cmd_tbl_t *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 = simple_strtoul(argv[1], NULL, 16);
	if (argc == 4)
		count = simple_strtoul(argv[3], NULL, 16);
	else
		count = 0;

	file = file_cbfs_find(argv[2]);
	if (!file) {
		if (file_cbfs_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);

	setenv_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(cmd_tbl_t *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_STAGE:
			type_name = "stage";
			break;
		case CBFS_TYPE_PAYLOAD:
			type_name = "payload";
			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_COMPONENT_CMOS_DEFAULT:
			type_name = "cmos default";
			break;
		case CBFS_COMPONENT_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(cmd_tbl_t *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
84cd9327 GB	1	/*
	2	* Copyright (c) 2011 The Chromium OS Authors. All rights reserved.
	3	*
1a459660	4	* SPDX-License-Identifier: GPL-2.0+
84cd9327 GB	5	*/
	6
	7	/*
	8	* CBFS commands
	9	*/
	10	#include <common.h>
	11	#include <command.h>
	12	#include <cbfs.h>
	13
633fb736 SG	14	static int do_cbfs_init(cmd_tbl_t *cmdtp, int flag, int argc,
633fb736 SG	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) {
	25	end_of_rom = (int)simple_strtoul(argv[1], &ep, 16);
	26	if (*ep) {
	27	puts("\n Invalid end of ROM \n");
	28	return 1;
	29	}
	30	}
	31	file_cbfs_init(end_of_rom);
	32	if (file_cbfs_result != CBFS_SUCCESS) {
	33	printf("%s.\n", file_cbfs_error());
	34	return 1;
	35	}
	36	return 0;
	37	}
	38
	39	U_BOOT_CMD(
	40	cbfsinit, 2, 0, do_cbfs_init,
	41	"initialize the cbfs driver",
	42	"[end of rom]\n"
	43	" - Initialize the cbfs driver. The optional 'end of rom'\n"
	44	" parameter specifies where the end of the ROM is that the\n"
	45	" CBFS is in. It defaults to 0xFFFFFFFF\n"
	46	);
	47
633fb736 SG	48	static int do_cbfs_fsload(cmd_tbl_t *cmdtp, int flag, int argc,
633fb736 SG	49	char *const argv[])
84cd9327 GB	50	{
	51	const struct cbfs_cachenode *file;
	52	unsigned long offset;
	53	unsigned long count;
84cd9327 GB	54	long size;
	55
	56	if (argc < 3) {
	57	printf("usage: cbfsload <addr> <filename> [bytes]\n");
	58	return 1;
	59	}
	60
	61	/* parse offset and count */
	62	offset = simple_strtoul(argv[1], NULL, 16);
	63	if (argc == 4)
	64	count = simple_strtoul(argv[3], NULL, 16);
	65	else
	66	count = 0;
	67
	68	file = file_cbfs_find(argv[2]);
	69	if (!file) {
	70	if (file_cbfs_result == CBFS_FILE_NOT_FOUND)
	71	printf("%s: %s\n", file_cbfs_error(), argv[2]);
	72	else
	73	printf("%s.\n", file_cbfs_error());
	74	return 1;
	75	}
	76
	77	printf("reading %s\n", file_cbfs_name(file));
	78
	79	size = file_cbfs_read(file, (void *)offset, count);
	80
	81	printf("\n%ld bytes read\n", size);
	82
41ef372c	83	setenv_hex("filesize", size);
84cd9327 GB	84
	85	return 0;
	86	}
	87
	88	U_BOOT_CMD(
	89	cbfsload, 4, 0, do_cbfs_fsload,
	90	"load binary file from a cbfs filesystem",
	91	"<addr> <filename> [bytes]\n"
	92	" - load binary file 'filename' from the cbfs to address 'addr'\n"
	93	);
	94
633fb736 SG	95	static int do_cbfs_ls(cmd_tbl_t *cmdtp, int flag, int argc,
633fb736 SG	96	char *const argv[])
84cd9327 GB	97	{
	98	const struct cbfs_cachenode *file = file_cbfs_get_first();
	99	int files = 0;
	100
	101	if (!file) {
	102	printf("%s.\n", file_cbfs_error());
	103	return 1;
	104	}
	105
	106	printf(" size type name\n");
	107	printf("------------------------------------------\n");
	108	while (file) {
a696d768	109	int type = file_cbfs_type(file);
84cd9327 GB	110	char *type_name = NULL;
	111	const char *filename = file_cbfs_name(file);
	112
	113	printf(" %8d", file_cbfs_size(file));
	114
	115	switch (type) {
	116	case CBFS_TYPE_STAGE:
	117	type_name = "stage";
	118	break;
	119	case CBFS_TYPE_PAYLOAD:
	120	type_name = "payload";
	121	break;
	122	case CBFS_TYPE_OPTIONROM:
	123	type_name = "option rom";
	124	break;
	125	case CBFS_TYPE_BOOTSPLASH:
	126	type_name = "boot splash";
	127	break;
	128	case CBFS_TYPE_RAW:
	129	type_name = "raw";
	130	break;
	131	case CBFS_TYPE_VSA:
	132	type_name = "vsa";
	133	break;
	134	case CBFS_TYPE_MBI:
	135	type_name = "mbi";
	136	break;
	137	case CBFS_TYPE_MICROCODE:
	138	type_name = "microcode";
	139	break;
	140	case CBFS_COMPONENT_CMOS_DEFAULT:
	141	type_name = "cmos default";
	142	break;
	143	case CBFS_COMPONENT_CMOS_LAYOUT:
	144	type_name = "cmos layout";
	145	break;
a696d768 SG	146	case -1:
a696d768 SG	147	case 0:
84cd9327 GB	148	type_name = "null";
	149	break;
	150	}
	151	if (type_name)
	152	printf(" %16s", type_name);
	153	else
	154	printf(" %16d", type);
	155
	156	if (filename[0])
	157	printf(" %s\n", filename);
	158	else
	159	printf(" %s\n", "(empty)");
	160	file_cbfs_get_next(&file);
	161	files++;
	162	}
	163
	164	printf("\n%d file(s)\n\n", files);
	165	return 0;
	166	}
	167
	168	U_BOOT_CMD(
	169	cbfsls, 1, 1, do_cbfs_ls,
	170	"list files",
	171	" - list the files in the cbfs\n"
	172	);
	173
633fb736 SG	174	static int do_cbfs_fsinfo(cmd_tbl_t *cmdtp, int flag, int argc,
633fb736 SG	175	char *const argv[])
84cd9327 GB	176	{
	177	const struct cbfs_header *header = file_cbfs_get_header();
	178
	179	if (!header) {
	180	printf("%s.\n", file_cbfs_error());
	181	return 1;
	182	}
	183
	184	printf("\n");
	185	printf("CBFS version: %#x\n", header->version);
	186	printf("ROM size: %#x\n", header->rom_size);
	187	printf("Boot block size: %#x\n", header->boot_block_size);
	188	printf("CBFS size: %#x\n",
	189	header->rom_size - header->boot_block_size - header->offset);
	190	printf("Alignment: %d\n", header->align);
	191	printf("Offset: %#x\n", header->offset);
	192	printf("\n");
	193
	194	return 0;
	195	}
	196
	197	U_BOOT_CMD(
	198	cbfsinfo, 1, 1, do_cbfs_fsinfo,
	199	"print information about filesystem",
	200	" - print information about the cbfs filesystem\n"
	201	);