1 files changed, 353 insertions, 110 deletions

diff --git a/common/bootm.c b/common/bootm.c
index 366f314555..4cc88eed76 100644
--- a/common/bootm.c
+++ b/common/bootm.c
@@ -1,15 +1,4 @@
-/*
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of
- * the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- */
+// SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <common.h>
 #include <bootm.h>
@@ -23,6 +12,8 @@
 #include <environment.h>
 #include <linux/stat.h>
 #include <magicvar.h>
+#include <uncompress.h>
+#include <zero_page.h>
 
 static LIST_HEAD(handler_list);
 
@@ -51,6 +42,7 @@ static struct image_handler *bootm_find_handler(enum filetype filetype,
 }
 
 static int bootm_appendroot;
+static int bootm_earlycon;
 static int bootm_provide_machine_id;
 static int bootm_verbosity;
 
@@ -58,12 +50,14 @@ void bootm_data_init_defaults(struct bootm_data *data)
 {
 	data->initrd_address = UIMAGE_INVALID_ADDRESS;
 	data->os_address = UIMAGE_SOME_ADDRESS;
+	data->os_entry = UIMAGE_SOME_ADDRESS;
 	data->oftree_file = getenv_nonempty("global.bootm.oftree");
 	data->tee_file = getenv_nonempty("global.bootm.tee");
 	data->os_file = getenv_nonempty("global.bootm.image");
 	getenv_ul("global.bootm.image.loadaddr", &data->os_address);
 	getenv_ul("global.bootm.initrd.loadaddr", &data->initrd_address);
 	data->initrd_file = getenv_nonempty("global.bootm.initrd");
+	data->root_dev = getenv_nonempty("global.bootm.root_dev");
 	data->verify = bootm_get_verify_mode();
 	data->appendroot = bootm_appendroot;
 	data->provide_machine_id = bootm_provide_machine_id;
@@ -77,6 +71,11 @@ enum bootm_verify bootm_get_verify_mode(void)
 	return bootm_verify_mode;
 }
 
+void bootm_set_verify_mode(enum bootm_verify mode)
+{
+	bootm_verify_mode = mode;
+}
+
 static const char * const bootm_verify_names[] = {
 #ifndef CONFIG_BOOTM_FORCE_SIGNED_IMAGES
 	[BOOTM_VERIFY_NONE] = "none",
@@ -119,9 +118,14 @@ int bootm_load_os(struct image_data *data, unsigned long load_address)
 
 		data->os_res = request_sdram_region("kernel",
 				load_address, kernel_size);
-		if (!data->os_res)
+		if (!data->os_res) {
+			pr_err("unable to request SDRAM region for kernel at"
+					" 0x%08llx-0x%08llx\n",
+				(unsigned long long)load_address,
+				(unsigned long long)load_address + kernel_size - 1);
 			return -ENOMEM;
-		memcpy((void *)load_address, kernel, kernel_size);
+		}
+		zero_page_memcpy((void *)load_address, kernel, kernel_size);
 		return 0;
 	}
 
@@ -138,6 +142,9 @@ int bootm_load_os(struct image_data *data, unsigned long load_address)
 		return 0;
 	}
 
+	if (IS_ENABLED(CONFIG_ELF) && data->elf)
+		return elf_load(data->elf);
+
 	if (data->os_file) {
 		data->os_res = file_to_sdram(data->os_file, load_address);
 		if (!data->os_res)
@@ -176,7 +183,7 @@ static int bootm_open_initrd_uimage(struct image_data *data)
 		if (bootm_get_verify_mode() > BOOTM_VERIFY_NONE) {
 			ret = uimage_verify(data->initrd);
 			if (ret) {
-				printf("Checking data crc failed with %s\n",
+				pr_err("Checking data crc failed with %s\n",
 					strerror(-ret));
 				return ret;
 			}
@@ -223,31 +230,38 @@ int bootm_load_initrd(struct image_data *data, unsigned long load_address)
 
 		ret = fit_open_image(data->os_fit, data->fit_config, "ramdisk",
 				     &initrd, &initrd_size);
-
+		if (ret) {
+			pr_err("Cannot open ramdisk image in FIT image: %s\n",
+					strerror(-ret));
+			return ret;
+		}
 		data->initrd_res = request_sdram_region("initrd",
 				load_address,
 				initrd_size);
-		if (!data->initrd_res)
+		if (!data->initrd_res) {
+			pr_err("unable to request SDRAM region for initrd at"
+					"0x%08llx-0x%08llx\n",
+				(unsigned long long)load_address,
+				(unsigned long long)load_address + initrd_size - 1);
 			return -ENOMEM;
+		}
 		memcpy((void *)load_address, initrd, initrd_size);
-		printf("Loaded initrd from FIT image\n");
+		pr_info("Loaded initrd from FIT image\n");
 		goto done1;
 	}
 
-	type = file_name_detect_type(data->initrd_file);
-
-	if ((int)type < 0) {
-		printf("could not open %s: %s\n", data->initrd_file,
-				strerror(-type));
-		return (int)type;
+	ret = file_name_detect_type(data->initrd_file, &type);
+	if (ret) {
+		pr_err("could not open initrd \"%s\": %s\n", data->initrd_file, strerror(-ret));
+		return ret;
 	}
 
 	if (type == filetype_uimage) {
 		int num;
 		ret = bootm_open_initrd_uimage(data);
 		if (ret) {
-			printf("loading initrd failed with %s\n",
-					strerror(-ret));
+			pr_err("loading initrd failed with %s\n",
+			       strerror(-ret));
 			return ret;
 		}
 
@@ -267,13 +281,13 @@ int bootm_load_initrd(struct image_data *data, unsigned long load_address)
 
 done:
 
-	printf("Loaded initrd %s '%s'", file_type_to_string(type),
+	pr_info("Loaded initrd %s '%s'", file_type_to_string(type),
 	       data->initrd_file);
 	if (type == filetype_uimage && data->initrd->header.ih_type == IH_TYPE_MULTI)
-		printf(", multifile image %s", data->initrd_part);
-	printf("\n");
+		pr_info(", multifile image %s", data->initrd_part);
+	pr_info("\n");
 done1:
-	printf("initrd is at %pa-%pa\n",
+	pr_info("initrd is at %pa-%pa\n",
 		&data->initrd_res->start,
 		&data->initrd_res->end);
 
@@ -289,7 +303,7 @@ static int bootm_open_oftree_uimage(struct image_data *data, size_t *size,
 	struct uimage_handle *of_handle;
 	int release = 0;
 
-	printf("Loading devicetree from '%s'@%d\n", oftree, num);
+	pr_info("Loading devicetree from '%s'@%d\n", oftree, num);
 
 	if (!IS_ENABLED(CONFIG_BOOTM_OFTREE_UIMAGE))
 		return -EINVAL;
@@ -313,7 +327,7 @@ static int bootm_open_oftree_uimage(struct image_data *data, size_t *size,
 
 	ft = file_detect_type(*fdt, *size);
 	if (ft != filetype_oftree) {
-		printf("%s is not an oftree but %s\n",
+		pr_err("%s is not an oftree but %s\n",
 			data->oftree_file, file_type_to_string(ft));
 		free(*fdt);
 		return -EINVAL;
@@ -352,16 +366,15 @@ void *bootm_get_devicetree(struct image_data *data)
 		if (ret)
 			return ERR_PTR(ret);
 
-		data->of_root_node = of_unflatten_dtb(of_tree);
+		data->of_root_node = of_unflatten_dtb(of_tree, of_size);
 	} else if (data->oftree_file) {
 		size_t size;
 
-		type = file_name_detect_type(data->oftree_file);
-
-		if ((int)type < 0) {
-			printf("could not open %s: %s\n", data->oftree_file,
-					strerror(-type));
-			return ERR_PTR((int)type);
+		ret = file_name_detect_type(data->oftree_file, &type);
+		if (ret) {
+			pr_err("could not open device tree \"%s\": %s\n", data->oftree_file,
+			       strerror(-ret));
+			return ERR_PTR(ret);
 		}
 
 		switch (type) {
@@ -369,7 +382,7 @@ void *bootm_get_devicetree(struct image_data *data)
 			ret = bootm_open_oftree_uimage(data, &size, &oftree);
 			break;
 		case filetype_oftree:
-			printf("Loading devicetree from '%s'\n", data->oftree_file);
+			pr_info("Loading devicetree from '%s'\n", data->oftree_file);
 			ret = read_file_2(data->oftree_file, &size, (void *)&oftree,
 					  FILESIZE_MAX);
 			break;
@@ -380,7 +393,7 @@ void *bootm_get_devicetree(struct image_data *data)
 		if (ret)
 			return ERR_PTR(ret);
 
-		data->of_root_node = of_unflatten_dtb(oftree);
+		data->of_root_node = of_unflatten_dtb(oftree, size);
 
 		free(oftree);
 
@@ -391,10 +404,13 @@ void *bootm_get_devicetree(struct image_data *data)
 		}
 
 	} else {
-		data->of_root_node = of_get_root_node();
-		if (!data->of_root_node)
+		struct device_node *root = of_get_root_node();
+
+		if (!root)
 			return NULL;
 
+		data->of_root_node = of_dup(root);
+
 		if (bootm_verbose(data) > 1 && data->of_root_node)
 			printf("using internal devicetree\n");
 	}
@@ -405,7 +421,9 @@ void *bootm_get_devicetree(struct image_data *data)
 		of_add_reserve_entry(data->initrd_res->start, data->initrd_res->end);
 	}
 
-	oftree = of_get_fixed_tree(data->of_root_node);
+	of_fix_tree(data->of_root_node);
+
+	oftree = of_flatten_dtb(data->of_root_node);
 	if (!oftree)
 		return ERR_PTR(-EINVAL);
 
@@ -439,14 +457,21 @@ int bootm_load_devicetree(struct image_data *data, void *fdt,
 
 	data->oftree_res = request_sdram_region("oftree", load_address,
 			fdt_size);
-	if (!data->oftree_res)
+	if (!data->oftree_res) {
+		pr_err("unable to request SDRAM region for device tree at"
+				"0x%08llx-0x%08llx\n",
+			(unsigned long long)load_address,
+			(unsigned long long)load_address + fdt_size - 1);
 		return -ENOMEM;
+	}
 
 	memcpy((void *)data->oftree_res->start, fdt, fdt_size);
 
 	of_print_cmdline(data->of_root_node);
-	if (bootm_verbose(data) > 1)
-		of_print_nodes(data->of_root_node, 0);
+	if (bootm_verbose(data) > 1) {
+		of_print_nodes(data->of_root_node, 0, ~0);
+		fdt_print_reserve_map(fdt);
+	}
 
 	return 0;
 }
@@ -455,6 +480,8 @@ int bootm_get_os_size(struct image_data *data)
 {
 	int ret;
 
+	if (data->elf)
+		return elf_get_mem_size(data->elf);
 	if (data->os)
 		return uimage_get_size(data->os, uimage_part_num(data->os_part));
 	if (data->os_fit)
@@ -482,7 +509,7 @@ static int bootm_open_os_uimage(struct image_data *data)
 	if (bootm_get_verify_mode() > BOOTM_VERIFY_NONE) {
 		ret = uimage_verify(data->os);
 		if (ret) {
-			printf("Checking data crc failed with %s\n",
+			pr_err("Checking data crc failed with %s\n",
 					strerror(-ret));
 			return ret;
 		}
@@ -490,8 +517,8 @@ static int bootm_open_os_uimage(struct image_data *data)
 
 	uimage_print_contents(data->os);
 
-	if (data->os->header.ih_arch != IH_ARCH) {
-		printf("Unsupported Architecture 0x%x\n",
+	if (IH_ARCH == IH_ARCH_INVALID || data->os->header.ih_arch != IH_ARCH) {
+		pr_err("Unsupported Architecture 0x%x\n",
 		       data->os->header.ih_arch);
 		return -EINVAL;
 	}
@@ -502,6 +529,88 @@ static int bootm_open_os_uimage(struct image_data *data)
 	return 0;
 }
 
+static int bootm_open_fit(struct image_data *data)
+{
+	struct fit_handle *fit;
+	struct fdt_header *header;
+	static const char *kernel_img = "kernel";
+	size_t flen, hlen;
+	int ret;
+
+	if (!IS_ENABLED(CONFIG_FITIMAGE))
+		return 0;
+
+	header = (struct fdt_header *)data->os_header;
+	flen = bootm_get_os_size(data);
+	hlen = fdt32_to_cpu(header->totalsize);
+
+	fit = fit_open(data->os_file, data->verbose, data->verify,
+		       min(flen, hlen));
+	if (IS_ERR(fit)) {
+		pr_err("Loading FIT image %s failed with: %pe\n", data->os_file, fit);
+		return PTR_ERR(fit);
+	}
+
+	data->os_fit = fit;
+
+	data->fit_config = fit_open_configuration(data->os_fit,
+						  data->os_part);
+	if (IS_ERR(data->fit_config)) {
+		pr_err("Cannot open FIT image configuration '%s'\n",
+		       data->os_part ? data->os_part : "default");
+		return PTR_ERR(data->fit_config);
+	}
+
+	ret = fit_open_image(data->os_fit, data->fit_config, kernel_img,
+			     &data->fit_kernel, &data->fit_kernel_size);
+	if (ret)
+		return ret;
+	if (data->os_address == UIMAGE_SOME_ADDRESS) {
+		ret = fit_get_image_address(data->os_fit,
+					    data->fit_config,
+					    kernel_img,
+					    "load", &data->os_address);
+		if (!ret)
+			pr_info("Load address from FIT '%s': 0x%lx\n",
+				kernel_img, data->os_address);
+		/* Note: Error case uses default value. */
+	}
+	if (data->os_entry == UIMAGE_SOME_ADDRESS) {
+		unsigned long entry;
+		ret = fit_get_image_address(data->os_fit,
+					    data->fit_config,
+					    kernel_img,
+					    "entry", &entry);
+		if (!ret) {
+			data->os_entry = entry - data->os_address;
+			pr_info("Entry address from FIT '%s': 0x%lx\n",
+				kernel_img, entry);
+		}
+		/* Note: Error case uses default value. */
+	}
+
+	return 0;
+}
+
+static int bootm_open_elf(struct image_data *data)
+{
+	struct elf_image *elf;
+
+	if (!IS_ENABLED(CONFIG_ELF))
+		return -ENOSYS;
+
+	elf = elf_open(data->os_file);
+	if (IS_ERR(elf))
+		return PTR_ERR(elf);
+
+	pr_info("Entry Point:  %08llx\n", elf->entry);
+
+	data->os_address = elf->entry;
+	data->elf = elf;
+
+	return 0;
+}
+
 static void bootm_print_info(struct image_data *data)
 {
 	if (data->os_res)
@@ -547,7 +656,7 @@ int bootm_boot(struct bootm_data *bootm_data)
 	size_t size;
 
 	if (!bootm_data->os_file) {
-		printf("no image given\n");
+		pr_err("no image given\n");
 		return -ENOENT;
 	}
 
@@ -568,7 +677,7 @@ int bootm_boot(struct bootm_data *bootm_data)
 
 	ret = read_file_2(data->os_file, &size, &data->os_header, PAGE_SIZE);
 	if (ret < 0 && ret != -EFBIG) {
-		printf("could not open %s: %s\n", data->os_file,
+		pr_err("could not open %s: %s\n", data->os_file,
 				strerror(-ret));
 		goto err_out;
 	}
@@ -578,7 +687,7 @@ int bootm_boot(struct bootm_data *bootm_data)
 	os_type = file_detect_type(data->os_header, PAGE_SIZE);
 
 	if (!data->force && os_type == filetype_unknown) {
-		printf("Unknown OS filetype (try -f)\n");
+		pr_err("Unknown OS filetype (try -f)\n");
 		ret = -EINVAL;
 		goto err_out;
 	}
@@ -592,68 +701,93 @@ int bootm_boot(struct bootm_data *bootm_data)
 		 */
 		data->oftree_file = NULL;
 		data->initrd_file = NULL;
+		data->tee_file = NULL;
 		if (os_type != filetype_oftree) {
-			printf("Signed boot and image is no FIT image, aborting\n");
+			pr_err("Signed boot and image is no FIT image, aborting\n");
 			ret = -EINVAL;
 			goto err_out;
 		}
 	}
 
-	if (IS_ENABLED(CONFIG_FITIMAGE) && os_type == filetype_oftree) {
-		struct fit_handle *fit;
-
-		fit = fit_open(data->os_file, data->verbose, data->verify);
-		if (IS_ERR(fit)) {
-			printf("Loading FIT image %s failed with: %s\n", data->os_file,
-			       strerrorp(fit));
-			ret = PTR_ERR(fit);
-			goto err_out;
-		}
-
-		data->os_fit = fit;
-
-		data->fit_config = fit_open_configuration(data->os_fit,
-							  data->os_part);
-		if (IS_ERR(data->fit_config)) {
-			printf("Cannot open FIT image configuration '%s'\n",
-			       data->os_part ? data->os_part : "default");
-			ret = PTR_ERR(data->fit_config);
-			goto err_out;
-		}
-
-		ret = fit_open_image(data->os_fit, data->fit_config, "kernel",
-				     &data->fit_kernel, &data->fit_kernel_size);
-		if (ret)
-			goto err_out;
+	switch (os_type) {
+	case filetype_oftree:
+		ret = bootm_open_fit(data);
+		break;
+	case filetype_uimage:
+		ret = bootm_open_os_uimage(data);
+		break;
+	case filetype_elf:
+		ret = bootm_open_elf(data);
+		break;
+	default:
+		ret = 0;
+		break;
 	}
 
-	if (os_type == filetype_uimage) {
-		ret = bootm_open_os_uimage(data);
-		if (ret) {
-			printf("Loading OS image failed with: %s\n",
-					strerror(-ret));
-			goto err_out;
-		}
+	if (ret) {
+		pr_err("Loading %s image failed with: %pe\n",
+		       file_type_to_short_string(os_type), ERR_PTR(ret));
+		goto err_out;
 	}
 
 	if (bootm_data->appendroot) {
 		char *rootarg;
 
-		rootarg = path_get_linux_rootarg(data->os_file);
-		if (!IS_ERR(rootarg)) {
-			printf("Adding \"%s\" to Kernel commandline\n", rootarg);
+		if (bootm_data->root_dev) {
+			const char *root_dev_name = devpath_to_name(bootm_data->root_dev);
+			const struct cdev *root_cdev = cdev_by_name(root_dev_name);
+
+			rootarg = cdev_get_linux_rootarg(root_cdev);
+			if (!rootarg) {
+				rootarg = ERR_PTR(-EINVAL);
+
+				if (!root_cdev)
+					pr_err("no cdev found for %s, cannot set root= option\n",
+						root_dev_name);
+				else if (!root_cdev->partuuid[0])
+					pr_err("%s doesn't have a PARTUUID, cannot set root= option\n",
+						root_dev_name);
+			}
+		} else {
+			rootarg = path_get_linux_rootarg(data->os_file);
+		}
+
+		if (IS_ERR(rootarg)) {
+			pr_err("Failed to append kernel cmdline parameter 'root='\n");
+		} else {
+			pr_info("Adding \"%s\" to Kernel commandline\n", rootarg);
 			globalvar_add_simple("linux.bootargs.bootm.appendroot",
 					     rootarg);
 			free(rootarg);
 		}
 	}
 
+	if (bootm_earlycon) {
+		struct console_device *console;
+		const char *earlycon = NULL;
+
+		for_each_console(console) {
+			if (!(console->f_active & (CONSOLE_STDOUT | CONSOLE_STDERR)))
+				continue;
+
+			earlycon = dev_get_param(&console->class_dev, "linux.bootargs.earlycon");
+			if (earlycon)
+				break;
+		}
+
+		if (!earlycon)
+			earlycon = "earlycon";
+
+		pr_info("Adding \"%s\" to Kernel commandline\n", earlycon);
+		globalvar_add_simple("linux.bootargs.bootm.earlycon", earlycon);
+	}
+
 	if (bootm_data->provide_machine_id) {
 		const char *machine_id = getenv_nonempty("global.machine_id");
 		char *machine_id_bootarg;
 
 		if (!machine_id) {
-			printf("Providing machine id is enabled but no machine id set\n");
+			pr_err("Providing machine id is enabled but no machine id set\n");
 			ret = -EINVAL;
 			goto err_out;
 		}
@@ -663,22 +797,24 @@ int bootm_boot(struct bootm_data *bootm_data)
 		free(machine_id_bootarg);
 	}
 
-	printf("\nLoading %s '%s'", file_type_to_string(os_type),
-			data->os_file);
+	pr_info("\nLoading %s '%s'", file_type_to_string(os_type),
+		data->os_file);
 	if (os_type == filetype_uimage &&
 			data->os->header.ih_type == IH_TYPE_MULTI)
-		printf(", multifile image %d", uimage_part_num(data->os_part));
-	printf("\n");
+		pr_info(", multifile image %d", uimage_part_num(data->os_part));
+	pr_info("\n");
 
 	if (data->os_address == UIMAGE_SOME_ADDRESS)
 		data->os_address = UIMAGE_INVALID_ADDRESS;
+	if (data->os_entry == UIMAGE_SOME_ADDRESS)
+		data->os_entry = 0;
 
 	handler = bootm_find_handler(os_type, data);
 	if (!handler) {
-		printf("no image handler found for image type %s\n",
-			file_type_to_string(os_type));
+		pr_err("no image handler found for image type %s\n",
+		       file_type_to_string(os_type));
 		if (os_type == filetype_uimage)
-			printf("and OS type: %d\n", data->os->header.ih_os);
+			pr_err("and OS type: %d\n", data->os->header.ih_os);
 		ret = -ENODEV;
 		goto err_out;
 	}
@@ -690,7 +826,7 @@ int bootm_boot(struct bootm_data *bootm_data)
 
 	ret = handler->bootm(data);
 	if (data->dryrun)
-		printf("Dryrun. Aborted\n");
+		pr_info("Dryrun. Aborted\n");
 
 err_out:
 	if (data->os_res)
@@ -705,11 +841,14 @@ err_out:
 		uimage_close(data->initrd);
 	if (data->os)
 		uimage_close(data->os);
+	if (IS_ENABLED(CONFIG_ELF) && data->elf)
+		elf_close(data->elf);
 	if (IS_ENABLED(CONFIG_FITIMAGE) && data->os_fit)
 		fit_close(data->os_fit);
-	if (data->of_root_node && data->of_root_node != of_get_root_node())
+	if (data->of_root_node)
 		of_delete_node(data->of_root_node);
 
+	globalvar_remove("linux.bootargs.bootm.earlycon");
 	globalvar_remove("linux.bootargs.bootm.appendroot");
 	free(data->os_header);
 	free(data->os_file);
@@ -721,13 +860,101 @@ err_out:
 	return ret;
 }
 
+static int do_bootm_compressed(struct image_data *img_data)
+{
+	struct bootm_data bootm_data = {
+		.oftree_file = img_data->oftree_file,
+		.initrd_file = img_data->initrd_file,
+		.tee_file = img_data->tee_file,
+		.verbose = img_data->verbose,
+		.verify = img_data->verify,
+		.force = img_data->force,
+		.dryrun = img_data->dryrun,
+		.initrd_address = img_data->initrd_address,
+		.os_address = img_data->os_address,
+		.os_entry = img_data->os_entry,
+	};
+	int from, to, ret;
+	char *dstpath;
+
+	from = open(img_data->os_file, O_RDONLY);
+	if (from < 0)
+		return -ENODEV;
+
+	dstpath = make_temp("bootm-compressed");
+	if (!dstpath) {
+		ret = -ENOMEM;
+		goto fail_from;
+	}
+
+	to = open(dstpath, O_CREAT | O_WRONLY);
+	if (to < 0) {
+		ret = -ENODEV;
+		goto fail_make_temp;
+	}
+
+	ret = uncompress_fd_to_fd(from, to, uncompress_err_stdout);
+	if (ret)
+		goto fail_to;
+
+	bootm_data.os_file = dstpath;
+	ret = bootm_boot(&bootm_data);
+
+fail_to:
+	close(to);
+	unlink(dstpath);
+fail_make_temp:
+	free(dstpath);
+fail_from:
+	close(from);
+	return ret;
+}
+
+static struct image_handler bzip2_bootm_handler = {
+	.name = "BZIP2 compressed file",
+	.bootm = do_bootm_compressed,
+	.filetype = filetype_bzip2,
+};
+
+static struct image_handler gzip_bootm_handler = {
+	.name = "GZIP compressed file",
+	.bootm = do_bootm_compressed,
+	.filetype = filetype_gzip,
+};
+
+static struct image_handler lzo_bootm_handler = {
+	.name = "LZO compressed file",
+	.bootm = do_bootm_compressed,
+	.filetype = filetype_lzo_compressed,
+};
+
+static struct image_handler lz4_bootm_handler = {
+	.name = "LZ4 compressed file",
+	.bootm = do_bootm_compressed,
+	.filetype = filetype_lz4_compressed,
+};
+
+static struct image_handler xz_bootm_handler = {
+	.name = "XZ compressed file",
+	.bootm = do_bootm_compressed,
+	.filetype = filetype_xz_compressed,
+};
+
+static struct image_handler zstd_bootm_handler = {
+	.name = "ZSTD compressed file",
+	.bootm = do_bootm_compressed,
+	.filetype = filetype_zstd_compressed,
+};
+
 static int bootm_init(void)
 {
 	globalvar_add_simple("bootm.image", NULL);
 	globalvar_add_simple("bootm.image.loadaddr", NULL);
 	globalvar_add_simple("bootm.oftree", NULL);
+	globalvar_add_simple("bootm.root_dev", NULL);
 	globalvar_add_simple("bootm.tee", NULL);
 	globalvar_add_simple_bool("bootm.appendroot", &bootm_appendroot);
+	globalvar_add_simple_bool("bootm.earlycon", &bootm_earlycon);
 	globalvar_add_simple_bool("bootm.provide_machine_id", &bootm_provide_machine_id);
 	if (IS_ENABLED(CONFIG_BOOTM_INITRD)) {
 		globalvar_add_simple("bootm.initrd", NULL);
@@ -742,18 +969,34 @@ static int bootm_init(void)
 	globalvar_add_simple_enum("bootm.verify", (unsigned int *)&bootm_verify_mode,
 				  bootm_verify_names, ARRAY_SIZE(bootm_verify_names));
 
+
+	if (IS_ENABLED(CONFIG_BZLIB))
+		register_image_handler(&bzip2_bootm_handler);
+	if (IS_ENABLED(CONFIG_ZLIB))
+		register_image_handler(&gzip_bootm_handler);
+	if (IS_ENABLED(CONFIG_LZO_DECOMPRESS))
+		register_image_handler(&lzo_bootm_handler);
+	if (IS_ENABLED(CONFIG_LZ4_DECOMPRESS))
+		register_image_handler(&lz4_bootm_handler);
+	if (IS_ENABLED(CONFIG_XZ_DECOMPRESS))
+		register_image_handler(&xz_bootm_handler);
+	if (IS_ENABLED(CONFIG_ZSTD_DECOMPRESS))
+		register_image_handler(&zstd_bootm_handler);
+
 	return 0;
 }
 late_initcall(bootm_init);
 
 BAREBOX_MAGICVAR(bootargs, "Linux kernel parameters");
-BAREBOX_MAGICVAR_NAMED(global_bootm_image, global.bootm.image, "bootm default boot image");
-BAREBOX_MAGICVAR_NAMED(global_bootm_image_loadaddr, global.bootm.image.loadaddr, "bootm default boot image loadaddr");
-BAREBOX_MAGICVAR_NAMED(global_bootm_initrd, global.bootm.initrd, "bootm default initrd");
-BAREBOX_MAGICVAR_NAMED(global_bootm_initrd_loadaddr, global.bootm.initrd.loadaddr, "bootm default initrd loadaddr");
-BAREBOX_MAGICVAR_NAMED(global_bootm_oftree, global.bootm.oftree, "bootm default oftree");
-BAREBOX_MAGICVAR_NAMED(global_bootm_tee, global.bootm.tee, "bootm default tee image");
-BAREBOX_MAGICVAR_NAMED(global_bootm_verify, global.bootm.verify, "bootm default verify level");
-BAREBOX_MAGICVAR_NAMED(global_bootm_verbose, global.bootm.verbose, "bootm default verbosity level (0=quiet)");
-BAREBOX_MAGICVAR_NAMED(global_bootm_appendroot, global.bootm.appendroot, "Add root= option to Kernel to mount rootfs from the device the Kernel comes from");
-BAREBOX_MAGICVAR_NAMED(global_bootm_provide_machine_id, global.bootm.provide_machine_id, "If true, add systemd.machine_id= with value of global.machine_id to Kernel");
+BAREBOX_MAGICVAR(global.bootm.image, "bootm default boot image");
+BAREBOX_MAGICVAR(global.bootm.image.loadaddr, "bootm default boot image loadaddr");
+BAREBOX_MAGICVAR(global.bootm.initrd, "bootm default initrd");
+BAREBOX_MAGICVAR(global.bootm.initrd.loadaddr, "bootm default initrd loadaddr");
+BAREBOX_MAGICVAR(global.bootm.oftree, "bootm default oftree");
+BAREBOX_MAGICVAR(global.bootm.tee, "bootm default tee image");
+BAREBOX_MAGICVAR(global.bootm.verify, "bootm default verify level");
+BAREBOX_MAGICVAR(global.bootm.verbose, "bootm default verbosity level (0=quiet)");
+BAREBOX_MAGICVAR(global.bootm.earlycon, "Add earlycon option to Kernel for early log output");
+BAREBOX_MAGICVAR(global.bootm.appendroot, "Add root= option to Kernel to mount rootfs from the device the Kernel comes from (default, device can be overridden via global.bootm.root_dev)");
+BAREBOX_MAGICVAR(global.bootm.root_dev, "bootm default root device (overrides default device in global.bootm.appendroot)");
+BAREBOX_MAGICVAR(global.bootm.provide_machine_id, "If true, append systemd.machine_id=$global.machine_id to Kernel command line");