[J-u-boot.git] / boot / bootmeth_script.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Bootmethod for booting via a U-Boot script
 *
 * Copyright 2021 Google LLC
 * Written by Simon Glass <[email protected]>
 */

#define LOG_CATEGORY UCLASS_BOOTSTD

#include <common.h>
#include <blk.h>
#include <bootflow.h>
#include <bootmeth.h>
#include <bootstd.h>
#include <dm.h>
#include <env.h>
#include <fs.h>
#include <image.h>
#include <malloc.h>
#include <mapmem.h>
#include <net.h>

#define SCRIPT_FNAME1	"boot.scr.uimg"
#define SCRIPT_FNAME2	"boot.scr"

static int script_check(struct udevice *dev, struct bootflow_iter *iter)
{
	/* This works on block devices, network devices and SPI Flash */
	if (iter->method_flags & BOOTFLOW_METHF_PXE_ONLY)
		return log_msg_ret("pxe", -ENOTSUPP);

	return 0;
}

/**
 * script_fill_info() - Decode the U-Boot script to find out distro info
 *
 * @bflow: Bootflow to process
 * @return 0 if OK, -ve on error
 */
static int script_fill_info(struct bootflow *bflow)
{
	char *name = NULL;
	char *data;
	uint len;
	int ret;

	log_debug("parsing bflow file size %x\n", bflow->size);

	ret = image_locate_script(bflow->buf, bflow->size, NULL, NULL, &data, &len);
	if (!ret) {
		if (strstr(data, "armbianEnv"))
			name = "Armbian";
	}

	if (name) {
		bflow->os_name = strdup(name);
		if (!bflow->os_name)
			return log_msg_ret("os", -ENOMEM);
	}

	return 0;
}

static int script_read_bootflow_file(struct udevice *bootstd,
				     struct bootflow *bflow)
{
	struct blk_desc *desc = NULL;
	const char *const *prefixes;
	const char *prefix;
	int ret, i;

	ret = uclass_first_device_err(UCLASS_BOOTSTD, &bootstd);
	if (ret)
		return log_msg_ret("std", ret);

	if (bflow->blk) {
		/* We require a partition table */
		if (!bflow->part)
			return -ENOENT;
		 desc = dev_get_uclass_plat(bflow->blk);
	}

	prefixes = bootstd_get_prefixes(bootstd);
	i = 0;
	do {
		prefix = prefixes ? prefixes[i] : NULL;

		ret = bootmeth_try_file(bflow, desc, prefix, SCRIPT_FNAME1);
		if (ret)
			ret = bootmeth_try_file(bflow, desc, prefix,
						SCRIPT_FNAME2);
	} while (ret && prefixes && prefixes[++i]);
	if (ret)
		return log_msg_ret("try", ret);

	bflow->subdir = strdup(prefix ? prefix : "");
	if (!bflow->subdir)
		return log_msg_ret("prefix", -ENOMEM);

	ret = bootmeth_alloc_file(bflow, 0x10000, ARCH_DMA_MINALIGN);
	if (ret)
		return log_msg_ret("read", ret);

	ret = script_fill_info(bflow);
	if (ret)
		return log_msg_ret("inf", ret);

	ret = bootmeth_alloc_other(bflow, "boot.bmp", &bflow->logo,
				   &bflow->logo_size);
	/* ignore error */

	return 0;
}

static int script_read_bootflow_net(struct bootflow *bflow)
{
	const char *addr_str;
	int size, ret;
	char *fname;
	ulong addr;

	/* figure out the load address */
	addr_str = env_get("scriptaddr");
	addr = addr_str ? hextoul(addr_str, NULL) : image_load_addr;

	fname = env_get("boot_script_dhcp");
	if (!fname)
		return log_msg_ret("dhc", -EINVAL);

	ret = dhcp_run(addr, fname, true);
	if (ret)
		return log_msg_ret("dhc", ret);

	size = env_get_hex("filesize", 0);
	if (!size)
		return log_msg_ret("sz", -EINVAL);

	bflow->buf = malloc(size + 1);
	if (!bflow->buf)
		return log_msg_ret("buf", -ENOMEM);
	memcpy(bflow->buf, map_sysmem(addr, size), size);
	bflow->buf[size] = '\0';
	bflow->size = size;
	bflow->state = BOOTFLOWST_READY;

	return 0;
}

static int script_read_bootflow(struct udevice *dev, struct bootflow *bflow)
{
	const struct udevice *media = dev_get_parent(bflow->dev);
	struct udevice *bootstd;
	int ret;

	ret = uclass_first_device_err(UCLASS_BOOTSTD, &bootstd);
	if (ret)
		return log_msg_ret("std", ret);

	if (IS_ENABLED(CONFIG_CMD_DHCP) &&
	    device_get_uclass_id(media) == UCLASS_ETH) {
		/* we only support reading from one device, so ignore 'dev' */
		ret = script_read_bootflow_net(bflow);
		if (ret)
			return log_msg_ret("net", ret);
	} else {
		ret = script_read_bootflow_file(bootstd, bflow);
		if (ret)
			return log_msg_ret("blk", ret);
	}

	return 0;
}

static int script_set_bootflow(struct udevice *dev, struct bootflow *bflow,
			       char *buf, int size)
{
	buf[size] = '\0';
	bflow->buf = buf;
	bflow->size = size;
	bflow->state = BOOTFLOWST_READY;

	return 0;
}

static int script_boot(struct udevice *dev, struct bootflow *bflow)
{
	struct blk_desc *desc = dev_get_uclass_plat(bflow->blk);
	ulong addr;
	int ret = 0;

	if (desc->uclass_id == UCLASS_USB) {
		ret = env_set("devtype", "usb");
	} else {
		/* If the uclass is AHCI, but the driver is ATA
		 * (not scsi), set devtype to sata
		 */
		if (IS_ENABLED(CONFIG_SATA) &&
		    desc->uclass_id == UCLASS_AHCI)
			ret = env_set("devtype", "sata");
		else
			ret = env_set("devtype", blk_get_devtype(bflow->blk));
	}
	if (!ret)
		ret = env_set_hex("devnum", desc->devnum);
	if (!ret)
		ret = env_set_hex("distro_bootpart", bflow->part);
	if (!ret)
		ret = env_set("prefix", bflow->subdir);
	if (!ret && IS_ENABLED(CONFIG_ARCH_SUNXI) &&
	    !strcmp("mmc", blk_get_devtype(bflow->blk)))
		ret = env_set_hex("mmc_bootdev", desc->devnum);
	if (ret)
		return log_msg_ret("env", ret);

	log_debug("devtype: %s\n", env_get("devtype"));
	log_debug("devnum: %s\n", env_get("devnum"));
	log_debug("distro_bootpart: %s\n", env_get("distro_bootpart"));
	log_debug("prefix: %s\n", env_get("prefix"));
	log_debug("mmc_bootdev: %s\n", env_get("mmc_bootdev"));

	addr = map_to_sysmem(bflow->buf);
	ret = cmd_source_script(addr, NULL, NULL);
	if (ret)
		return log_msg_ret("boot", ret);

	return 0;
}

static int script_bootmeth_bind(struct udevice *dev)
{
	struct bootmeth_uc_plat *plat = dev_get_uclass_plat(dev);

	plat->desc = IS_ENABLED(CONFIG_BOOTSTD_FULL) ?
		"Script boot from a block device" : "script";

	return 0;
}

static struct bootmeth_ops script_bootmeth_ops = {
	.check		= script_check,
	.read_bootflow	= script_read_bootflow,
	.set_bootflow	= script_set_bootflow,
	.read_file	= bootmeth_common_read_file,
	.boot		= script_boot,
};

static const struct udevice_id script_bootmeth_ids[] = {
	{ .compatible = "u-boot,script" },
	{ }
};

/* Put an number before 'script' to provide a default ordering */
U_BOOT_DRIVER(bootmeth_2script) = {
	.name		= "bootmeth_script",
	.id		= UCLASS_BOOTMETH,
	.of_match	= script_bootmeth_ids,
	.ops		= &script_bootmeth_ops,
	.bind		= script_bootmeth_bind,
};
Commit	Line	Data
d9409244 SG	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* Bootmethod for booting via a U-Boot script
	4	*
	5	* Copyright 2021 Google LLC
	6	* Written by Simon Glass <[email protected]>
	7	*/
	8
	9	#define LOG_CATEGORY UCLASS_BOOTSTD
	10
	11	#include <common.h>
	12	#include <blk.h>
	13	#include <bootflow.h>
	14	#include <bootmeth.h>
	15	#include <bootstd.h>
	16	#include <dm.h>
	17	#include <env.h>
	18	#include <fs.h>
	19	#include <image.h>
	20	#include <malloc.h>
	21	#include <mapmem.h>
5143a41e	22	#include <net.h>
d9409244 SG	23
	24	#define SCRIPT_FNAME1 "boot.scr.uimg"
	25	#define SCRIPT_FNAME2 "boot.scr"
	26
	27	static int script_check(struct udevice dev, struct bootflow_iter iter)
	28	{
5143a41e	29	/* This works on block devices, network devices and SPI Flash */
d9f48579 SG	30	if (iter->method_flags & BOOTFLOW_METHF_PXE_ONLY)
d9f48579 SG	31	return log_msg_ret("pxe", -ENOTSUPP);
d9409244 SG	32
	33	return 0;
	34	}
	35
2175e76a SG	36	/**
	37	* script_fill_info() - Decode the U-Boot script to find out distro info
	38	*
	39	* @bflow: Bootflow to process
	40	* @return 0 if OK, -ve on error
	41	*/
	42	static int script_fill_info(struct bootflow *bflow)
	43	{
	44	char *name = NULL;
	45	char *data;
	46	uint len;
	47	int ret;
	48
	49	log_debug("parsing bflow file size %x\n", bflow->size);
	50
	51	ret = image_locate_script(bflow->buf, bflow->size, NULL, NULL, &data, &len);
	52	if (!ret) {
	53	if (strstr(data, "armbianEnv"))
	54	name = "Armbian";
	55	}
	56
	57	if (name) {
	58	bflow->os_name = strdup(name);
	59	if (!bflow->os_name)
	60	return log_msg_ret("os", -ENOMEM);
	61	}
	62
	63	return 0;
	64	}
	65
5143a41e SG	66	static int script_read_bootflow_file(struct udevice *bootstd,
5143a41e SG	67	struct bootflow *bflow)
d9409244 SG	68	{
	69	struct blk_desc *desc = NULL;
	70	const char const prefixes;
d9409244 SG	71	const char *prefix;
	72	int ret, i;
	73
	74	ret = uclass_first_device_err(UCLASS_BOOTSTD, &bootstd);
	75	if (ret)
	76	return log_msg_ret("std", ret);
	77
5143a41e SG	78	if (bflow->blk) {
	79	/* We require a partition table */
	80	if (!bflow->part)
	81	return -ENOENT;
d9409244	82	desc = dev_get_uclass_plat(bflow->blk);
5143a41e	83	}
d9409244 SG	84
	85	prefixes = bootstd_get_prefixes(bootstd);
	86	i = 0;
	87	do {
	88	prefix = prefixes ? prefixes[i] : NULL;
	89
	90	ret = bootmeth_try_file(bflow, desc, prefix, SCRIPT_FNAME1);
	91	if (ret)
	92	ret = bootmeth_try_file(bflow, desc, prefix,
	93	SCRIPT_FNAME2);
	94	} while (ret && prefixes && prefixes[++i]);
	95	if (ret)
	96	return log_msg_ret("try", ret);
	97
	98	bflow->subdir = strdup(prefix ? prefix : "");
	99	if (!bflow->subdir)
	100	return log_msg_ret("prefix", -ENOMEM);
	101
deb746e0	102	ret = bootmeth_alloc_file(bflow, 0x10000, ARCH_DMA_MINALIGN);
d9409244 SG	103	if (ret)
	104	return log_msg_ret("read", ret);
	105
2175e76a SG	106	ret = script_fill_info(bflow);
	107	if (ret)
	108	return log_msg_ret("inf", ret);
	109
24d8e1b3 SG	110	ret = bootmeth_alloc_other(bflow, "boot.bmp", &bflow->logo,
	111	&bflow->logo_size);
	112	/* ignore error */
	113
d9409244 SG	114	return 0;
	115	}
	116
5143a41e SG	117	static int script_read_bootflow_net(struct bootflow *bflow)
	118	{
	119	const char *addr_str;
	120	int size, ret;
	121	char *fname;
	122	ulong addr;
	123
	124	/* figure out the load address */
	125	addr_str = env_get("scriptaddr");
	126	addr = addr_str ? hextoul(addr_str, NULL) : image_load_addr;
	127
	128	fname = env_get("boot_script_dhcp");
	129	if (!fname)
	130	return log_msg_ret("dhc", -EINVAL);
	131
	132	ret = dhcp_run(addr, fname, true);
	133	if (ret)
	134	return log_msg_ret("dhc", ret);
	135
	136	size = env_get_hex("filesize", 0);
	137	if (!size)
	138	return log_msg_ret("sz", -EINVAL);
	139
	140	bflow->buf = malloc(size + 1);
	141	if (!bflow->buf)
	142	return log_msg_ret("buf", -ENOMEM);
	143	memcpy(bflow->buf, map_sysmem(addr, size), size);
	144	bflow->buf[size] = '\0';
	145	bflow->size = size;
	146	bflow->state = BOOTFLOWST_READY;
	147
	148	return 0;
	149	}
	150
	151	static int script_read_bootflow(struct udevice dev, struct bootflow bflow)
	152	{
	153	const struct udevice *media = dev_get_parent(bflow->dev);
	154	struct udevice *bootstd;
	155	int ret;
	156
	157	ret = uclass_first_device_err(UCLASS_BOOTSTD, &bootstd);
	158	if (ret)
	159	return log_msg_ret("std", ret);
	160
	161	if (IS_ENABLED(CONFIG_CMD_DHCP) &&
	162	device_get_uclass_id(media) == UCLASS_ETH) {
	163	/* we only support reading from one device, so ignore 'dev' */
	164	ret = script_read_bootflow_net(bflow);
	165	if (ret)
	166	return log_msg_ret("net", ret);
	167	} else {
	168	ret = script_read_bootflow_file(bootstd, bflow);
	169	if (ret)
	170	return log_msg_ret("blk", ret);
	171	}
	172
	173	return 0;
	174	}
	175
	176	static int script_set_bootflow(struct udevice dev, struct bootflow bflow,
	177	char *buf, int size)
	178	{
	179	buf[size] = '\0';
	180	bflow->buf = buf;
181	bflow->size = size;
182	bflow->state = BOOTFLOWST_READY;
183
184	return 0;
185	}
186
d9409244 SG	187	static int script_boot(struct udevice dev, struct bootflow bflow)
	188	{
	189	struct blk_desc *desc = dev_get_uclass_plat(bflow->blk);
	190	ulong addr;
a7527fbb	191	int ret = 0;
d9409244	192
a7527fbb	193	if (desc->uclass_id == UCLASS_USB) {
7dde5620	194	ret = env_set("devtype", "usb");
a7527fbb TD	195	} else {
	196	/* If the uclass is AHCI, but the driver is ATA
	197	* (not scsi), set devtype to sata
	198	*/
	199	if (IS_ENABLED(CONFIG_SATA) &&
	200	desc->uclass_id == UCLASS_AHCI)
	201	ret = env_set("devtype", "sata");
	202	else
	203	ret = env_set("devtype", blk_get_devtype(bflow->blk));
	204	}
d9409244 SG	205	if (!ret)
d9409244 SG	206	ret = env_set_hex("devnum", desc->devnum);
25365879 SG	207	if (!ret)
25365879 SG	208	ret = env_set_hex("distro_bootpart", bflow->part);
d9409244 SG	209	if (!ret)
	210	ret = env_set("prefix", bflow->subdir);
	211	if (!ret && IS_ENABLED(CONFIG_ARCH_SUNXI) &&
	212	!strcmp("mmc", blk_get_devtype(bflow->blk)))
	213	ret = env_set_hex("mmc_bootdev", desc->devnum);
	214	if (ret)
	215	return log_msg_ret("env", ret);
	216
	217	log_debug("devtype: %s\n", env_get("devtype"));
	218	log_debug("devnum: %s\n", env_get("devnum"));
25365879	219	log_debug("distro_bootpart: %s\n", env_get("distro_bootpart"));
d9409244 SG	220	log_debug("prefix: %s\n", env_get("prefix"));
	221	log_debug("mmc_bootdev: %s\n", env_get("mmc_bootdev"));
	222
	223	addr = map_to_sysmem(bflow->buf);
30f3333d	224	ret = cmd_source_script(addr, NULL, NULL);
d9409244 SG	225	if (ret)
	226	return log_msg_ret("boot", ret);
	227
	228	return 0;
	229	}
	230
	231	static int script_bootmeth_bind(struct udevice *dev)
	232	{
	233	struct bootmeth_uc_plat *plat = dev_get_uclass_plat(dev);
	234
	235	plat->desc = IS_ENABLED(CONFIG_BOOTSTD_FULL) ?
	236	"Script boot from a block device" : "script";
	237
	238	return 0;
	239	}
	240
	241	static struct bootmeth_ops script_bootmeth_ops = {
	242	.check = script_check,
	243	.read_bootflow = script_read_bootflow,
5143a41e	244	.set_bootflow = script_set_bootflow,
d9409244 SG	245	.read_file = bootmeth_common_read_file,
	246	.boot = script_boot,
	247	};
	248
	249	static const struct udevice_id script_bootmeth_ids[] = {
	250	{ .compatible = "u-boot,script" },
	251	{ }
	252	};
	253
5986d46f SG	254	/* Put an number before 'script' to provide a default ordering */
5986d46f SG	255	U_BOOT_DRIVER(bootmeth_2script) = {
d9409244 SG	256	.name = "bootmeth_script",
	257	.id = UCLASS_BOOTMETH,
	258	.of_match = script_bootmeth_ids,
	259	.ops = &script_bootmeth_ops,
	260	.bind = script_bootmeth_bind,
	261	};