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

// SPDX-License-Identifier: GPL-2.0+
/*
 * 'cedit' command
 *
 * Copyright 2023 Google LLC
 * Written by Simon Glass <[email protected]>
 */

#include <abuf.h>
#include <cedit.h>
#include <command.h>
#include <dm.h>
#include <expo.h>
#include <fs.h>
#include <malloc.h>
#include <mapmem.h>
#include <dm/ofnode.h>
#include <linux/sizes.h>

struct expo *cur_exp;

static int check_cur_expo(void)
{
	if (!cur_exp) {
		printf("No expo loaded\n");
		return -ENOENT;
	}

	return 0;
}

static int do_cedit_load(struct cmd_tbl *cmdtp, int flag, int argc,
			 char *const argv[])
{
	const char *fname;
	struct expo *exp;
	oftree tree;
	ulong size;
	void *buf;
	int ret;

	if (argc < 4)
		return CMD_RET_USAGE;
	fname = argv[3];

	ret = fs_load_alloc(argv[1], argv[2], argv[3], SZ_1M, 0, &buf, &size);
	if (ret) {
		printf("File not found\n");
		return CMD_RET_FAILURE;
	}

	tree = oftree_from_fdt(buf);
	if (!oftree_valid(tree)) {
		printf("Cannot create oftree\n");
		return CMD_RET_FAILURE;
	}

	ret = expo_build(oftree_root(tree), &exp);
	oftree_dispose(tree);
	if (ret) {
		printf("Failed to build expo: %dE\n", ret);
		return CMD_RET_FAILURE;
	}

	cur_exp = exp;

	return 0;
}

static int do_cedit_write_fdt(struct cmd_tbl *cmdtp, int flag, int argc,
			      char *const argv[])
{
	const char *fname;
	struct abuf buf;
	loff_t bytes;
	int ret;

	if (argc < 4)
		return CMD_RET_USAGE;
	fname = argv[3];

	if (check_cur_expo())
		return CMD_RET_FAILURE;

	ret = cedit_write_settings(cur_exp, &buf);
	if (ret) {
		printf("Failed to write settings: %dE\n", ret);
		return CMD_RET_FAILURE;
	}

	if (fs_set_blk_dev(argv[1], argv[2], FS_TYPE_ANY))
		return CMD_RET_FAILURE;

	ret = fs_write(fname, map_to_sysmem(abuf_data(&buf)), 0,
		       abuf_size(&buf), &bytes);
	if (ret)
		return CMD_RET_FAILURE;

	return 0;
}

static int do_cedit_read_fdt(struct cmd_tbl *cmdtp, int flag, int argc,
			     char *const argv[])
{
	const char *fname;
	void *buf;
	oftree tree;
	ulong size;
	int ret;

	if (argc < 4)
		return CMD_RET_USAGE;
	fname = argv[3];

	ret = fs_load_alloc(argv[1], argv[2], argv[3], SZ_1M, 0, &buf, &size);
	if (ret) {
		printf("File not found\n");
		return CMD_RET_FAILURE;
	}

	tree = oftree_from_fdt(buf);
	if (!oftree_valid(tree)) {
		free(buf);
		printf("Cannot create oftree\n");
		return CMD_RET_FAILURE;
	}

	ret = cedit_read_settings(cur_exp, tree);
	oftree_dispose(tree);
	free(buf);
	if (ret) {
		printf("Failed to read settings: %dE\n", ret);
		return CMD_RET_FAILURE;
	}

	return 0;
}

static int do_cedit_write_env(struct cmd_tbl *cmdtp, int flag, int argc,
			      char *const argv[])
{
	bool verbose;
	int ret;

	if (check_cur_expo())
		return CMD_RET_FAILURE;

	verbose = argc > 1 && !strcmp(argv[1], "-v");

	ret = cedit_write_settings_env(cur_exp, verbose);
	if (ret) {
		printf("Failed to write settings to environment: %dE\n", ret);
		return CMD_RET_FAILURE;
	}

	return 0;
}

static int do_cedit_read_env(struct cmd_tbl *cmdtp, int flag, int argc,
			     char *const argv[])
{
	bool verbose;
	int ret;

	if (check_cur_expo())
		return CMD_RET_FAILURE;

	verbose = argc > 1 && !strcmp(argv[1], "-v");

	ret = cedit_read_settings_env(cur_exp, verbose);
	if (ret) {
		printf("Failed to read settings from environment: %dE\n", ret);
		return CMD_RET_FAILURE;
	}

	return 0;
}

static int do_cedit_write_cmos(struct cmd_tbl *cmdtp, int flag, int argc,
			       char *const argv[])
{
	struct udevice *dev;
	bool verbose = false;
	int ret;

	if (check_cur_expo())
		return CMD_RET_FAILURE;

	if (argc > 1 && !strcmp(argv[1], "-v")) {
		verbose = true;
		argc--;
		argv++;
	}

	if (argc > 1)
		ret = uclass_get_device_by_name(UCLASS_RTC, argv[1], &dev);
	else
		ret = uclass_first_device_err(UCLASS_RTC, &dev);
	if (ret) {
		printf("Failed to get RTC device: %dE\n", ret);
		return CMD_RET_FAILURE;
	}

	if (cedit_write_settings_cmos(cur_exp, dev, verbose)) {
		printf("Failed to write settings to CMOS\n");
		return CMD_RET_FAILURE;
	}

	return 0;
}

static int do_cedit_read_cmos(struct cmd_tbl *cmdtp, int flag, int argc,
			      char *const argv[])
{
	struct udevice *dev;
	bool verbose = false;
	int ret;

	if (check_cur_expo())
		return CMD_RET_FAILURE;

	if (argc > 1 && !strcmp(argv[1], "-v")) {
		verbose = true;
		argc--;
		argv++;
	}

	if (argc > 1)
		ret = uclass_get_device_by_name(UCLASS_RTC, argv[1], &dev);
	else
		ret = uclass_first_device_err(UCLASS_RTC, &dev);
	if (ret) {
		printf("Failed to get RTC device: %dE\n", ret);
		return CMD_RET_FAILURE;
	}

	ret = cedit_read_settings_cmos(cur_exp, dev, verbose);
	if (ret) {
		printf("Failed to read settings from CMOS: %dE\n", ret);
		return CMD_RET_FAILURE;
	}

	return 0;
}

static int do_cedit_run(struct cmd_tbl *cmdtp, int flag, int argc,
			char *const argv[])
{
	ofnode node;
	int ret;

	if (check_cur_expo())
		return CMD_RET_FAILURE;

	node = ofnode_path("/bootstd/cedit-theme");
	if (ofnode_valid(node)) {
		ret = expo_apply_theme(cur_exp, node);
		if (ret)
			return CMD_RET_FAILURE;
	} else {
		log_warning("No theme found\n");
	}
	ret = cedit_run(cur_exp);
	if (ret) {
		log_err("Failed (err=%dE)\n", ret);
		return CMD_RET_FAILURE;
	}

	return 0;
}

U_BOOT_LONGHELP(cedit,
	"load <interface> <dev[:part]> <filename>   - load config editor\n"
	"cedit read_fdt <i/f> <dev[:part]> <filename>     - read settings\n"
	"cedit write_fdt <i/f> <dev[:part]> <filename>    - write settings\n"
	"cedit read_env [-v]                              - read settings from env vars\n"
	"cedit write_env [-v]                             - write settings to env vars\n"
	"cedit read_cmos [-v] [dev]                       - read settings from CMOS RAM\n"
	"cedit write_cmos [-v] [dev]                      - write settings to CMOS RAM\n"
	"cedit run                                        - run config editor");

U_BOOT_CMD_WITH_SUBCMDS(cedit, "Configuration editor", cedit_help_text,
	U_BOOT_SUBCMD_MKENT(load, 5, 1, do_cedit_load),
	U_BOOT_SUBCMD_MKENT(read_fdt, 5, 1, do_cedit_read_fdt),
	U_BOOT_SUBCMD_MKENT(write_fdt, 5, 1, do_cedit_write_fdt),
	U_BOOT_SUBCMD_MKENT(read_env, 2, 1, do_cedit_read_env),
	U_BOOT_SUBCMD_MKENT(write_env, 2, 1, do_cedit_write_env),
	U_BOOT_SUBCMD_MKENT(read_cmos, 2, 1, do_cedit_read_cmos),
	U_BOOT_SUBCMD_MKENT(write_cmos, 2, 1, do_cedit_write_cmos),
	U_BOOT_SUBCMD_MKENT(run, 1, 1, do_cedit_run),
);
Commit	Line	Data
a0874dc4 SG	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* 'cedit' command
	4	*
	5	* Copyright 2023 Google LLC
	6	* Written by Simon Glass <[email protected]>
	7	*/
	8
2dee81fe	9	#include <abuf.h>
040b0468	10	#include <cedit.h>
a0874dc4	11	#include <command.h>
eb6c71b5	12	#include <dm.h>
a0874dc4 SG	13	#include <expo.h>
a0874dc4 SG	14	#include <fs.h>
2dee81fe SG	15	#include <malloc.h>
2dee81fe SG	16	#include <mapmem.h>
a0874dc4 SG	17	#include <dm/ofnode.h>
	18	#include <linux/sizes.h>
	19
	20	struct expo *cur_exp;
	21
2dee81fe SG	22	static int check_cur_expo(void)
	23	{
	24	if (!cur_exp) {
	25	printf("No expo loaded\n");
	26	return -ENOENT;
	27	}
	28
	29	return 0;
	30	}
	31
a0874dc4 SG	32	static int do_cedit_load(struct cmd_tbl *cmdtp, int flag, int argc,
	33	char *const argv[])
	34	{
	35	const char *fname;
	36	struct expo *exp;
	37	oftree tree;
	38	ulong size;
	39	void *buf;
	40	int ret;
	41
	42	if (argc < 4)
	43	return CMD_RET_USAGE;
	44	fname = argv[3];
	45
	46	ret = fs_load_alloc(argv[1], argv[2], argv[3], SZ_1M, 0, &buf, &size);
	47	if (ret) {
	48	printf("File not found\n");
	49	return CMD_RET_FAILURE;
	50	}
	51
	52	tree = oftree_from_fdt(buf);
	53	if (!oftree_valid(tree)) {
	54	printf("Cannot create oftree\n");
	55	return CMD_RET_FAILURE;
	56	}
	57
	58	ret = expo_build(oftree_root(tree), &exp);
	59	oftree_dispose(tree);
	60	if (ret) {
	61	printf("Failed to build expo: %dE\n", ret);
	62	return CMD_RET_FAILURE;
	63	}
	64
	65	cur_exp = exp;
	66
	67	return 0;
	68	}
	69
2dee81fe SG	70	static int do_cedit_write_fdt(struct cmd_tbl *cmdtp, int flag, int argc,
	71	char *const argv[])
	72	{
	73	const char *fname;
	74	struct abuf buf;
	75	loff_t bytes;
	76	int ret;
	77
	78	if (argc < 4)
	79	return CMD_RET_USAGE;
	80	fname = argv[3];
	81
	82	if (check_cur_expo())
	83	return CMD_RET_FAILURE;
	84
	85	ret = cedit_write_settings(cur_exp, &buf);
	86	if (ret) {
	87	printf("Failed to write settings: %dE\n", ret);
	88	return CMD_RET_FAILURE;
	89	}
	90
	91	if (fs_set_blk_dev(argv[1], argv[2], FS_TYPE_ANY))
	92	return CMD_RET_FAILURE;
	93
	94	ret = fs_write(fname, map_to_sysmem(abuf_data(&buf)), 0,
	95	abuf_size(&buf), &bytes);
	96	if (ret)
	97	return CMD_RET_FAILURE;
	98
	99	return 0;
	100	}
	101
472317cb SG	102	static int do_cedit_read_fdt(struct cmd_tbl *cmdtp, int flag, int argc,
	103	char *const argv[])
	104	{
	105	const char *fname;
	106	void *buf;
	107	oftree tree;
	108	ulong size;
	109	int ret;
	110
	111	if (argc < 4)
	112	return CMD_RET_USAGE;
	113	fname = argv[3];
	114
	115	ret = fs_load_alloc(argv[1], argv[2], argv[3], SZ_1M, 0, &buf, &size);
	116	if (ret) {
	117	printf("File not found\n");
	118	return CMD_RET_FAILURE;
	119	}
	120
	121	tree = oftree_from_fdt(buf);
	122	if (!oftree_valid(tree)) {
	123	free(buf);
	124	printf("Cannot create oftree\n");
	125	return CMD_RET_FAILURE;
	126	}
	127
	128	ret = cedit_read_settings(cur_exp, tree);
	129	oftree_dispose(tree);
	130	free(buf);
	131	if (ret) {
	132	printf("Failed to read settings: %dE\n", ret);
	133	return CMD_RET_FAILURE;
	134	}
	135
	136	return 0;
	137	}
	138
fc9c0e07 SG	139	static int do_cedit_write_env(struct cmd_tbl *cmdtp, int flag, int argc,
	140	char *const argv[])
	141	{
	142	bool verbose;
	143	int ret;
	144
	145	if (check_cur_expo())
	146	return CMD_RET_FAILURE;
	147
	148	verbose = argc > 1 && !strcmp(argv[1], "-v");
	149
	150	ret = cedit_write_settings_env(cur_exp, verbose);
	151	if (ret) {
	152	printf("Failed to write settings to environment: %dE\n", ret);
	153	return CMD_RET_FAILURE;
	154	}
	155
	156	return 0;
	157	}
	158
bcf2b720 SG	159	static int do_cedit_read_env(struct cmd_tbl *cmdtp, int flag, int argc,
	160	char *const argv[])
	161	{
	162	bool verbose;
	163	int ret;
	164
	165	if (check_cur_expo())
	166	return CMD_RET_FAILURE;
	167
	168	verbose = argc > 1 && !strcmp(argv[1], "-v");
	169
	170	ret = cedit_read_settings_env(cur_exp, verbose);
	171	if (ret) {
	172	printf("Failed to read settings from environment: %dE\n", ret);
	173	return CMD_RET_FAILURE;
	174	}
	175
	176	return 0;
	177	}
	178
eb6c71b5 SG	179	static int do_cedit_write_cmos(struct cmd_tbl *cmdtp, int flag, int argc,
	180	char *const argv[])
	181	{
	182	struct udevice *dev;
	183	bool verbose = false;
	184	int ret;
	185
	186	if (check_cur_expo())
	187	return CMD_RET_FAILURE;
	188
	189	if (argc > 1 && !strcmp(argv[1], "-v")) {
	190	verbose = true;
	191	argc--;
	192	argv++;
	193	}
	194
	195	if (argc > 1)
	196	ret = uclass_get_device_by_name(UCLASS_RTC, argv[1], &dev);
	197	else
	198	ret = uclass_first_device_err(UCLASS_RTC, &dev);
	199	if (ret) {
	200	printf("Failed to get RTC device: %dE\n", ret);
	201	return CMD_RET_FAILURE;
	202	}
	203
	204	if (cedit_write_settings_cmos(cur_exp, dev, verbose)) {
	205	printf("Failed to write settings to CMOS\n");
	206	return CMD_RET_FAILURE;
	207	}
	208
	209	return 0;
	210	}
	211
cfc402db SG	212	static int do_cedit_read_cmos(struct cmd_tbl *cmdtp, int flag, int argc,
	213	char *const argv[])
	214	{
	215	struct udevice *dev;
	216	bool verbose = false;
	217	int ret;
	218
	219	if (check_cur_expo())
	220	return CMD_RET_FAILURE;
	221
	222	if (argc > 1 && !strcmp(argv[1], "-v")) {
	223	verbose = true;
	224	argc--;
	225	argv++;
	226	}
	227
	228	if (argc > 1)
	229	ret = uclass_get_device_by_name(UCLASS_RTC, argv[1], &dev);
	230	else
	231	ret = uclass_first_device_err(UCLASS_RTC, &dev);
	232	if (ret) {
	233	printf("Failed to get RTC device: %dE\n", ret);
	234	return CMD_RET_FAILURE;
	235	}
	236
	237	ret = cedit_read_settings_cmos(cur_exp, dev, verbose);
	238	if (ret) {
	239	printf("Failed to read settings from CMOS: %dE\n", ret);
	240	return CMD_RET_FAILURE;
	241	}
	242
	243	return 0;
	244	}
	245
a0874dc4 SG	246	static int do_cedit_run(struct cmd_tbl *cmdtp, int flag, int argc,
	247	char *const argv[])
	248	{
	249	ofnode node;
	250	int ret;
	251
2dee81fe	252	if (check_cur_expo())
a0874dc4	253	return CMD_RET_FAILURE;
a0874dc4	254
2045ca5c	255	node = ofnode_path("/bootstd/cedit-theme");
a0874dc4 SG	256	if (ofnode_valid(node)) {
	257	ret = expo_apply_theme(cur_exp, node);
	258	if (ret)
	259	return CMD_RET_FAILURE;
	260	} else {
	261	log_warning("No theme found\n");
	262	}
	263	ret = cedit_run(cur_exp);
	264	if (ret) {
	265	log_err("Failed (err=%dE)\n", ret);
	266	return CMD_RET_FAILURE;
	267	}
	268
	269	return 0;
	270	}
	271
3616218b	272	U_BOOT_LONGHELP(cedit,
a0874dc4	273	"load <interface> <dev[:part]> <filename> - load config editor\n"
472317cb	274	"cedit read_fdt <i/f> <dev[:part]> <filename> - read settings\n"
2dee81fe	275	"cedit write_fdt <i/f> <dev[:part]> <filename> - write settings\n"
bcf2b720	276	"cedit read_env [-v] - read settings from env vars\n"
fc9c0e07	277	"cedit write_env [-v] - write settings to env vars\n"
cfc402db	278	"cedit read_cmos [-v] [dev] - read settings from CMOS RAM\n"
eb6c71b5	279	"cedit write_cmos [-v] [dev] - write settings to CMOS RAM\n"
3616218b	280	"cedit run - run config editor");
a0874dc4 SG	281
	282	U_BOOT_CMD_WITH_SUBCMDS(cedit, "Configuration editor", cedit_help_text,
	283	U_BOOT_SUBCMD_MKENT(load, 5, 1, do_cedit_load),
472317cb	284	U_BOOT_SUBCMD_MKENT(read_fdt, 5, 1, do_cedit_read_fdt),
2dee81fe	285	U_BOOT_SUBCMD_MKENT(write_fdt, 5, 1, do_cedit_write_fdt),
bcf2b720	286	U_BOOT_SUBCMD_MKENT(read_env, 2, 1, do_cedit_read_env),
fc9c0e07	287	U_BOOT_SUBCMD_MKENT(write_env, 2, 1, do_cedit_write_env),
cfc402db	288	U_BOOT_SUBCMD_MKENT(read_cmos, 2, 1, do_cedit_read_cmos),
eb6c71b5	289	U_BOOT_SUBCMD_MKENT(write_cmos, 2, 1, do_cedit_write_cmos),
a0874dc4 SG	290	U_BOOT_SUBCMD_MKENT(run, 1, 1, do_cedit_run),
a0874dc4 SG	291	);