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

// SPDX-License-Identifier: GPL-2.0+
/*
 * Bootmethod for distro boot (syslinux boot from a block device)
 *
 * Copyright 2021 Google LLC
 * Written by Simon Glass <[email protected]>
 */

#define LOG_CATEGORY UCLASS_BOOTSTD

#include <common.h>
#include <bootdev.h>
#include <bootflow.h>
#include <bootmeth.h>
#include <bootstd.h>
#include <command.h>
#include <distro.h>
#include <dm.h>
#include <fs.h>
#include <malloc.h>
#include <mapmem.h>
#include <mmc.h>
#include <pxe_utils.h>

static int disto_getfile(struct pxe_context *ctx, const char *file_path,
			 char *file_addr, ulong *sizep)
{
	struct distro_info *info = ctx->userdata;
	ulong addr;
	int ret;

	addr = simple_strtoul(file_addr, NULL, 16);

	/* Allow up to 1GB */
	*sizep = 1 << 30;
	ret = bootmeth_read_file(info->dev, info->bflow, file_path, addr,
				 sizep);
	if (ret)
		return log_msg_ret("read", ret);

	return 0;
}

static int distro_check(struct udevice *dev, struct bootflow_iter *iter)
{
	int ret;

	/* This only works on block devices */
	ret = bootflow_iter_uses_blk_dev(iter);
	if (ret)
		return log_msg_ret("blk", ret);

	return 0;
}

static int distro_read_bootflow(struct udevice *dev, struct bootflow *bflow)
{
	struct blk_desc *desc;
	const char *const *prefixes;
	struct udevice *bootstd;
	const char *prefix;
	loff_t size;
	int ret, i;

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

	/* If a block device, we require a partition table */
	if (bflow->blk && !bflow->part)
		return -ENOENT;

	prefixes = bootstd_get_prefixes(bootstd);
	i = 0;
	desc = bflow->blk ? dev_get_uclass_plat(bflow->blk) : NULL;
	do {
		prefix = prefixes ? prefixes[i] : NULL;

		ret = bootmeth_try_file(bflow, desc, prefix, DISTRO_FNAME);
	} while (ret && prefixes && prefixes[++i]);
	if (ret)
		return log_msg_ret("try", ret);
	size = bflow->size;

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

	return 0;
}

static int distro_boot(struct udevice *dev, struct bootflow *bflow)
{
	struct cmd_tbl cmdtp = {};	/* dummy */
	struct pxe_context ctx;
	struct distro_info info;
	ulong addr;
	int ret;

	addr = map_to_sysmem(bflow->buf);
	info.dev = dev;
	info.bflow = bflow;
	ret = pxe_setup_ctx(&ctx, &cmdtp, disto_getfile, &info, true,
			    bflow->subdir);
	if (ret)
		return log_msg_ret("ctx", -EINVAL);

	ret = pxe_process(&ctx, addr, false);
	if (ret)
		return log_msg_ret("bread", -EINVAL);

	return 0;
}

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

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

	return 0;
}

static struct bootmeth_ops distro_bootmeth_ops = {
	.check		= distro_check,
	.read_bootflow	= distro_read_bootflow,
	.read_file	= bootmeth_common_read_file,
	.boot		= distro_boot,
};

static const struct udevice_id distro_bootmeth_ids[] = {
	{ .compatible = "u-boot,distro-syslinux" },
	{ }
};

U_BOOT_DRIVER(bootmeth_distro) = {
	.name		= "bootmeth_distro",
	.id		= UCLASS_BOOTMETH,
	.of_match	= distro_bootmeth_ids,
	.ops		= &distro_bootmeth_ops,
	.bind		= distro_bootmeth_bind,
};
Commit	Line	Data
31aefaf8 SG	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* Bootmethod for distro boot (syslinux boot from a block device)
	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 <bootdev.h>
	13	#include <bootflow.h>
	14	#include <bootmeth.h>
	15	#include <bootstd.h>
	16	#include <command.h>
	17	#include <distro.h>
	18	#include <dm.h>
	19	#include <fs.h>
	20	#include <malloc.h>
	21	#include <mapmem.h>
	22	#include <mmc.h>
	23	#include <pxe_utils.h>
	24
	25	static int disto_getfile(struct pxe_context ctx, const char file_path,
	26	char file_addr, ulong sizep)
	27	{
	28	struct distro_info *info = ctx->userdata;
	29	ulong addr;
	30	int ret;
	31
	32	addr = simple_strtoul(file_addr, NULL, 16);
	33
	34	/* Allow up to 1GB */
	35	*sizep = 1 << 30;
	36	ret = bootmeth_read_file(info->dev, info->bflow, file_path, addr,
	37	sizep);
	38	if (ret)
	39	return log_msg_ret("read", ret);
	40
	41	return 0;
	42	}
	43
	44	static int distro_check(struct udevice dev, struct bootflow_iter iter)
	45	{
	46	int ret;
	47
	48	/* This only works on block devices */
	49	ret = bootflow_iter_uses_blk_dev(iter);
	50	if (ret)
	51	return log_msg_ret("blk", ret);
	52
	53	return 0;
	54	}
	55
	56	static int distro_read_bootflow(struct udevice dev, struct bootflow bflow)
	57	{
	58	struct blk_desc *desc;
	59	const char const prefixes;
	60	struct udevice *bootstd;
	61	const char *prefix;
	62	loff_t size;
	63	int ret, i;
	64
65	ret = uclass_first_device_err(UCLASS_BOOTSTD, &bootstd);
66	if (ret)
67	return log_msg_ret("std", ret);
68
69	/* If a block device, we require a partition table */
70	if (bflow->blk && !bflow->part)
71	return -ENOENT;
72
73	prefixes = bootstd_get_prefixes(bootstd);
74	i = 0;
75	desc = bflow->blk ? dev_get_uclass_plat(bflow->blk) : NULL;
76	do {
77	prefix = prefixes ? prefixes[i] : NULL;
78
79	ret = bootmeth_try_file(bflow, desc, prefix, DISTRO_FNAME);
80	} while (ret && prefixes && prefixes[++i]);
81	if (ret)
82	return log_msg_ret("try", ret);
83	size = bflow->size;
84
85	ret = bootmeth_alloc_file(bflow, 0x10000, 1);
86	if (ret)
87	return log_msg_ret("read", ret);
88
89	return 0;
90	}
91
92	static int distro_boot(struct udevice dev, struct bootflow bflow)
93	{
94	struct cmd_tbl cmdtp = {}; /* dummy */
95	struct pxe_context ctx;
96	struct distro_info info;
97	ulong addr;
98	int ret;
99
100	addr = map_to_sysmem(bflow->buf);
101	info.dev = dev;
102	info.bflow = bflow;
103	ret = pxe_setup_ctx(&ctx, &cmdtp, disto_getfile, &info, true,
104	bflow->subdir);
105	if (ret)
106	return log_msg_ret("ctx", -EINVAL);
107
108	ret = pxe_process(&ctx, addr, false);
109	if (ret)
110	return log_msg_ret("bread", -EINVAL);
111
112	return 0;
113	}
114
115	static int distro_bootmeth_bind(struct udevice *dev)
116	{
117	struct bootmeth_uc_plat *plat = dev_get_uclass_plat(dev);
118
119	plat->desc = IS_ENABLED(CONFIG_BOOTSTD_FULL) ?
120	"Syslinux boot from a block device" : "syslinux";
121
122	return 0;
123	}
124
125	static struct bootmeth_ops distro_bootmeth_ops = {
126	.check = distro_check,
127	.read_bootflow = distro_read_bootflow,
128	.read_file = bootmeth_common_read_file,
129	.boot = distro_boot,
130	};
131
132	static const struct udevice_id distro_bootmeth_ids[] = {
133	{ .compatible = "u-boot,distro-syslinux" },
134	{ }
135	};
136
137	U_BOOT_DRIVER(bootmeth_distro) = {
138	.name = "bootmeth_distro",
139	.id = UCLASS_BOOTMETH,
140	.of_match = distro_bootmeth_ids,
141	.ops = &distro_bootmeth_ops,
142	.bind = distro_bootmeth_bind,
143	};