common/android_bootloader.c - u-boot-mtk - Git at Google

 /*
  * Copyright (C) 2016 The Android Open Source Project
  *
  * SPDX-License-Identifier: BSD-2-Clause
  */

 #include <android_bootloader.h>
 #include <android_bootloader_message.h>

 #include <android_ab.h>
 #include <cli.h>
 #include <common.h>
 #include <log.h>
 #include <malloc.h>

 #define ANDROID_PARTITION_BOOT "boot"
 #define ANDROID_PARTITION_RECOVERY "recovery"
 #define ANDROID_PARTITION_SYSTEM "system"

 #define ANDROID_ARG_SLOT_SUFFIX "androidboot.slot_suffix="
 #define ANDROID_ARG_ROOT "root="

 static int android_bootloader_message_load(
 	struct blk_desc *dev_desc,
 	const disk_partition_t *part_info,
 	struct bootloader_message *message)
 {
 	ulong message_blocks = sizeof(struct bootloader_message) /
 	    part_info->blksz;
 	if (message_blocks > part_info->size) {
 		printf("misc partition too small.\n");
 		return -1;
 	}

 	if (blk_dread(dev_desc, part_info->start, message_blocks, message) !=
 	    message_blocks) {
 		printf("Could not read from misc partition\n");
 		return -1;
 	}
 	debug("ANDROID: Loaded BCB, %lu blocks.\n", message_blocks);
 	return 0;
 }

 static int android_bootloader_message_write(
 	struct blk_desc *dev_desc,
 	const disk_partition_t *part_info,
 	struct bootloader_message *message)
 {
 	ulong message_blocks = sizeof(struct bootloader_message) /
 	    part_info->blksz;
 	if (message_blocks > part_info->size) {
 		printf("misc partition too small.\n");
 		return -1;
 	}

 	if (blk_dwrite(dev_desc, part_info->start, message_blocks, message) !=
 	    message_blocks) {
 		printf("Could not write to misc partition\n");
 		return -1;
 	}
 	debug("ANDROID: Wrote new BCB, %lu blocks.\n", message_blocks);
 	return 0;
 }

 static enum android_boot_mode android_bootloader_load_and_clear_mode(
 	struct blk_desc *dev_desc,
 	const disk_partition_t *misc_part_info)
 {
 	struct bootloader_message bcb;

 #ifdef CONFIG_FASTBOOT
 	char *bootloader_str;

 	/* Check for message from bootloader stored in RAM from a previous boot.
 	 */
 	bootloader_str = (char *)CONFIG_FASTBOOT_BUF_ADDR;
 	if (!strcmp("reboot-bootloader", bootloader_str)) {
 		bootloader_str[0] = '\0';
 		return ANDROID_BOOT_MODE_BOOTLOADER;
 	}
 #endif

 	/* Check and update the BCB message if needed. */
 	if (android_bootloader_message_load(dev_desc, misc_part_info, &bcb) <
 	    0) {
 		printf("WARNING: Unable to load the BCB.\n");
 		return ANDROID_BOOT_MODE_NORMAL;
 	}

 	if (!strcmp("bootonce-bootloader", bcb.command)) {
 		/* Erase the message in the BCB since this value should be used
 		 * only once.
 		 */
 		memset(bcb.command, 0, sizeof(bcb.command));
 		android_bootloader_message_write(dev_desc, misc_part_info,
 						 &bcb);
 		return ANDROID_BOOT_MODE_BOOTLOADER;
 	}

 	if (!strcmp("boot-recovery", bcb.command))
 		return ANDROID_BOOT_MODE_RECOVERY;

 	return ANDROID_BOOT_MODE_NORMAL;
 }

 /**
  * Return the reboot reason string for the passed boot mode.
  *
  * @param mode	The Android Boot mode.
  * @return a pointer to the reboot reason string for mode.
  */
 static const char *android_boot_mode_str(enum android_boot_mode mode)
 {
 	switch (mode) {
 	case ANDROID_BOOT_MODE_NORMAL:
 		return "(none)";
 	case ANDROID_BOOT_MODE_RECOVERY:
 		return "recovery";
 	case ANDROID_BOOT_MODE_BOOTLOADER:
 		return "bootloader";
 	}
 	return NULL;
 }

 static int android_part_get_info_by_name_suffix(struct blk_desc *dev_desc,
 						const char *base_name,
 						const char *slot_suffix,
 						disk_partition_t *part_info)
 {
 	char *part_name;
 	int part_num;
 	size_t part_name_len;

 	part_name_len = strlen(base_name) + 1;
 	if (slot_suffix)
 		part_name_len += strlen(slot_suffix);
 	part_name = malloc(part_name_len);
 	if (!part_name)
 		return -1;
 	strcpy(part_name, base_name);
 	if (slot_suffix)
 		strcat(part_name, slot_suffix);

 	part_num = part_get_info_by_name(dev_desc, part_name, part_info);
 	if (part_num < 0) {
 		debug("ANDROID: Could not find partition \"%s\"\n", part_name);
 		part_num = -1;
 	}

 	free(part_name);
 	return part_num;
 }

 static int android_bootloader_boot_bootloader(void)
 {
 	const char *fastboot_cmd = env_get("fastbootcmd");

 	if (fastboot_cmd)
 		return run_command(fastboot_cmd, CMD_FLAG_ENV);
 	return -1;
 }

 static int android_bootloader_boot_kernel(unsigned long kernel_address)
 {
 	char kernel_addr_str[12];
 	char *fdt_addr = env_get("fdtaddr");
 	char *bootm_args[] = {
 		"bootm", kernel_addr_str, kernel_addr_str, fdt_addr, NULL };

 	sprintf(kernel_addr_str, "0x%lx", kernel_address);

 	printf("Booting kernel at %s with fdt at %s...\n\n\n",
 	       kernel_addr_str, fdt_addr);
 	do_bootm(NULL, 0, 4, bootm_args);

 	return -1;
 }

 static char *strjoin(const char **chunks, char separator)
 {
 	int len, joined_len = 0;
 	char *ret, *current;
 	const char **p;

 	for (p = chunks; *p; p++)
 		joined_len += strlen(*p) + 1;

 	if (!joined_len) {
 		ret = malloc(1);
 		if (ret)
 			ret[0] = '\0';
 		return ret;
 	}

 	ret = malloc(joined_len);
 	current = ret;
 	if (!ret)
 		return ret;

 	for (p = chunks; *p; p++) {
 		len = strlen(*p);
 		memcpy(current, *p, len);
 		current += len;
 		*current = separator;
 		current++;
 	}
 	/* Replace the last separator by a \0. */
 	current[-1] = '\0';
 	return ret;
 }

 /** android_assemble_cmdline - Assemble the command line to pass to the kernel
  * @return a newly allocated string
  */
 static char *android_assemble_cmdline(const char *slot_suffix,
 				      const char *extra_args)
 {
 	const char *cmdline_chunks[16];
 	const char **current_chunk = cmdline_chunks;
 	char *env_cmdline, *cmdline, *rootdev_input;
 	char *allocated_suffix = NULL;
 	char *allocated_rootdev = NULL;
 	unsigned long rootdev_len;

 	env_cmdline = env_get("bootargs");
 	if (env_cmdline)
 		*(current_chunk++) = env_cmdline;

 	/* The |slot_suffix| needs to be passed to the kernel to know what
 	 * slot to boot from.
 	 */
 	if (slot_suffix) {
 		allocated_suffix = malloc(strlen(ANDROID_ARG_SLOT_SUFFIX) +
 					  strlen(slot_suffix));
 		strcpy(allocated_suffix, ANDROID_ARG_SLOT_SUFFIX);
 		strcat(allocated_suffix, slot_suffix);
 		*(current_chunk++) = allocated_suffix;
 	}

 	rootdev_input = env_get("android_rootdev");
 	if (rootdev_input) {
 		rootdev_len = strlen(ANDROID_ARG_ROOT) + CONFIG_SYS_CBSIZE + 1;
 		allocated_rootdev = malloc(rootdev_len);
 		strcpy(allocated_rootdev, ANDROID_ARG_ROOT);
 		cli_simple_process_macros(rootdev_input,
 					  allocated_rootdev +
 					  strlen(ANDROID_ARG_ROOT));
 		/* Make sure that the string is null-terminated since the
 		 * previous could not copy to the end of the input string if it
 		 * is too big.
 		 */
 		allocated_rootdev[rootdev_len - 1] = '\0';
 		*(current_chunk++) = allocated_rootdev;
 	}

 	if (extra_args)
 		*(current_chunk++) = extra_args;

 	*(current_chunk++) = NULL;
 	cmdline = strjoin(cmdline_chunks, ' ');
 	free(allocated_suffix);
 	free(allocated_rootdev);
 	return cmdline;
 }

 int android_bootloader_boot_flow(struct blk_desc *dev_desc,
 				 const disk_partition_t *misc_part_info,
 				 const char *slot,
 				 unsigned long kernel_address)
 {
 	enum android_boot_mode mode;
 	disk_partition_t boot_part_info;
 	int boot_part_num;
 	int ret;
 	char *command_line;
 	char slot_suffix[3];
 	const char *mode_cmdline = NULL;
 	const char *boot_partition = ANDROID_PARTITION_BOOT;
 #ifdef CONFIG_ANDROID_SYSTEM_AS_ROOT
 	int system_part_num
 	disk_partition_t system_part_info;
 #endif

 	/* Determine the boot mode and clear its value for the next boot if
 	 * needed.
 	 */
 	mode = android_bootloader_load_and_clear_mode(dev_desc, misc_part_info);
 	printf("ANDROID: reboot reason: \"%s\"\n", android_boot_mode_str(mode));

 	switch (mode) {
 	case ANDROID_BOOT_MODE_NORMAL:
 #ifdef CONFIG_ANDROID_SYSTEM_AS_ROOT
 		/* In normal mode, we load the kernel from "boot" but append
 		 * "skip_initramfs" to the cmdline to make it ignore the
 		 * recovery initramfs in the boot partition.
 		 */
 		mode_cmdline = "skip_initramfs";
 #endif
 		break;
 	case ANDROID_BOOT_MODE_RECOVERY:
 #ifdef CONFIG_ANDROID_SYSTEM_AS_ROOT
 		/* In recovery mode we still boot the kernel from "boot" but
 		 * don't skip the initramfs so it boots to recovery.
 		 */
 #else
 		boot_partition = ANDROID_PARTITION_RECOVERY;
 #endif
 		break;
 	case ANDROID_BOOT_MODE_BOOTLOADER:
 		/* Bootloader mode enters fastboot. If this operation fails we
 		 * simply return since we can't recover from this situation by
 		 * switching to another slot.
 		 */
 		return android_bootloader_boot_bootloader();
 	}

 	/* Look for an optional slot suffix override. */
 	if (!slot || !slot[0])
 		slot = env_get("android_slot_suffix");

 	slot_suffix[0] = '\0';
 	if (slot && slot[0]) {
 		slot_suffix[0] = '_';
 		slot_suffix[1] = slot[0];
 		slot_suffix[2] = '\0';
 	} else {
 #ifdef CONFIG_ANDROID_AB
 		bool normal_boot = (mode == ANDROID_BOOT_MODE_NORMAL);
 		int slot_num = ab_select_slot(dev_desc, misc_part_info, normal_boot);
 		if (slot_num < 0) {
 			log_err("Could not determine Android boot slot.\n");
 			return -1;
 		}
 		slot_suffix[0] = '_';
 		slot_suffix[1] = BOOT_SLOT_NAME(slot_num);
 		slot_suffix[2] = '\0';
 #endif
 	}

 	/* Load the kernel from the desired "boot" partition. */
 	boot_part_num =
 	    android_part_get_info_by_name_suffix(dev_desc, boot_partition,
 						 slot_suffix, &boot_part_info);
 	if (boot_part_num < 0)
 		return -1;
 	debug("ANDROID: Loading kernel from \"%s\", partition %d.\n",
 	      boot_part_info.name, boot_part_num);

 #ifdef CONFIG_ANDROID_SYSTEM_AS_ROOT
 	system_part_num =
 	    android_part_get_info_by_name_suffix(dev_desc,
 						 ANDROID_PARTITION_SYSTEM,
 						 slot_suffix,
 						 &system_part_info);
 	if (system_part_num < 0)
 		return -1;
 	debug("ANDROID: Using system image from \"%s\", partition %d.\n",
 	      system_part_info.name, system_part_num);
 #endif

 	ret = android_image_load(dev_desc, &boot_part_info, kernel_address,
 				 -1UL);
 	if (ret < 0)
 		return ret;

 #ifdef CONFIG_ANDROID_SYSTEM_AS_ROOT
 	/* Set Android root variables. */
 	env_set_ulong("android_root_devnum", dev_desc->devnum);
 	env_set_ulong("android_root_partnum", system_part_num);
 #endif
 	env_set("android_slotsufix", slot_suffix);

 	/* Assemble the command line */
 	command_line = android_assemble_cmdline(slot_suffix, mode_cmdline);
 	env_set("bootargs", command_line);

 	debug("ANDROID: bootargs: \"%s\"\n", command_line);

 	android_bootloader_boot_kernel(kernel_address);

 	/* TODO: If the kernel doesn't boot mark the selected slot as bad. */
 	return -1;
 }
	/*
	* Copyright (C) 2016 The Android Open Source Project
	*
	* SPDX-License-Identifier: BSD-2-Clause
	*/

	#include <android_bootloader.h>
	#include <android_bootloader_message.h>

	#include <android_ab.h>
	#include <cli.h>
	#include <common.h>
	#include <log.h>
	#include <malloc.h>

	#define ANDROID_PARTITION_BOOT "boot"
	#define ANDROID_PARTITION_RECOVERY "recovery"
	#define ANDROID_PARTITION_SYSTEM "system"

	#define ANDROID_ARG_SLOT_SUFFIX "androidboot.slot_suffix="
	#define ANDROID_ARG_ROOT "root="

	static int android_bootloader_message_load(
	struct blk_desc *dev_desc,
	const disk_partition_t *part_info,
	struct bootloader_message *message)
	{
	ulong message_blocks = sizeof(struct bootloader_message) /
	part_info->blksz;
	if (message_blocks > part_info->size) {
	printf("misc partition too small.\n");
	return -1;
	}

	if (blk_dread(dev_desc, part_info->start, message_blocks, message) !=
	message_blocks) {
	printf("Could not read from misc partition\n");
	return -1;
	}
	debug("ANDROID: Loaded BCB, %lu blocks.\n", message_blocks);
	return 0;
	}

	static int android_bootloader_message_write(
	struct blk_desc *dev_desc,
	const disk_partition_t *part_info,
	struct bootloader_message *message)
	{
	ulong message_blocks = sizeof(struct bootloader_message) /
	part_info->blksz;
	if (message_blocks > part_info->size) {
	printf("misc partition too small.\n");
	return -1;
	}

	if (blk_dwrite(dev_desc, part_info->start, message_blocks, message) !=
	message_blocks) {
	printf("Could not write to misc partition\n");
	return -1;
	}
	debug("ANDROID: Wrote new BCB, %lu blocks.\n", message_blocks);
	return 0;
	}

	static enum android_boot_mode android_bootloader_load_and_clear_mode(
	struct blk_desc *dev_desc,
	const disk_partition_t *misc_part_info)
	{
	struct bootloader_message bcb;

	#ifdef CONFIG_FASTBOOT
	char *bootloader_str;

	/* Check for message from bootloader stored in RAM from a previous boot.
	*/
	bootloader_str = (char *)CONFIG_FASTBOOT_BUF_ADDR;
	if (!strcmp("reboot-bootloader", bootloader_str)) {
	bootloader_str[0] = '\0';
	return ANDROID_BOOT_MODE_BOOTLOADER;
	}
	#endif

	/* Check and update the BCB message if needed. */
	if (android_bootloader_message_load(dev_desc, misc_part_info, &bcb) <
	0) {
	printf("WARNING: Unable to load the BCB.\n");
	return ANDROID_BOOT_MODE_NORMAL;
	}

	if (!strcmp("bootonce-bootloader", bcb.command)) {
	/* Erase the message in the BCB since this value should be used
	* only once.
	*/
	memset(bcb.command, 0, sizeof(bcb.command));
	android_bootloader_message_write(dev_desc, misc_part_info,
	&bcb);
	return ANDROID_BOOT_MODE_BOOTLOADER;
	}

	if (!strcmp("boot-recovery", bcb.command))
	return ANDROID_BOOT_MODE_RECOVERY;

	return ANDROID_BOOT_MODE_NORMAL;
	}

	/**
	* Return the reboot reason string for the passed boot mode.
	*
	* @param mode The Android Boot mode.
	* @return a pointer to the reboot reason string for mode.
	*/
	static const char *android_boot_mode_str(enum android_boot_mode mode)
	{
	switch (mode) {
	case ANDROID_BOOT_MODE_NORMAL:
	return "(none)";
	case ANDROID_BOOT_MODE_RECOVERY:
	return "recovery";
	case ANDROID_BOOT_MODE_BOOTLOADER:
	return "bootloader";
	}
	return NULL;
	}

	static int android_part_get_info_by_name_suffix(struct blk_desc *dev_desc,
	const char *base_name,
	const char *slot_suffix,
	disk_partition_t *part_info)
	{
	char *part_name;
	int part_num;
	size_t part_name_len;

	part_name_len = strlen(base_name) + 1;
	if (slot_suffix)
	part_name_len += strlen(slot_suffix);
	part_name = malloc(part_name_len);
	if (!part_name)
	return -1;
	strcpy(part_name, base_name);
	if (slot_suffix)
	strcat(part_name, slot_suffix);

	part_num = part_get_info_by_name(dev_desc, part_name, part_info);
	if (part_num < 0) {
	debug("ANDROID: Could not find partition \"%s\"\n", part_name);
	part_num = -1;
	}

	free(part_name);
	return part_num;
	}

	static int android_bootloader_boot_bootloader(void)
	{
	const char *fastboot_cmd = env_get("fastbootcmd");

	if (fastboot_cmd)
	return run_command(fastboot_cmd, CMD_FLAG_ENV);
	return -1;
	}

	static int android_bootloader_boot_kernel(unsigned long kernel_address)
	{
	char kernel_addr_str[12];
	char *fdt_addr = env_get("fdtaddr");
	char *bootm_args[] = {
	"bootm", kernel_addr_str, kernel_addr_str, fdt_addr, NULL };

	sprintf(kernel_addr_str, "0x%lx", kernel_address);

	printf("Booting kernel at %s with fdt at %s...\n\n\n",
	kernel_addr_str, fdt_addr);
	do_bootm(NULL, 0, 4, bootm_args);

	return -1;
	}

	static char strjoin(const char *chunks, char separator)
	{
	int len, joined_len = 0;
	char ret, current;
	const char **p;

	for (p = chunks; *p; p++)
	joined_len += strlen(*p) + 1;

	if (!joined_len) {
	ret = malloc(1);
	if (ret)
	ret[0] = '\0';
	return ret;
	}

	ret = malloc(joined_len);
	current = ret;
	if (!ret)
	return ret;

	for (p = chunks; *p; p++) {
	len = strlen(*p);
	memcpy(current, *p, len);
	current += len;
	*current = separator;
	current++;
	}
	/* Replace the last separator by a \0. */
	current[-1] = '\0';
	return ret;
	}

	/** android_assemble_cmdline - Assemble the command line to pass to the kernel
	* @return a newly allocated string
	*/
	static char android_assemble_cmdline(const char slot_suffix,
	const char *extra_args)
	{
	const char *cmdline_chunks[16];
	const char **current_chunk = cmdline_chunks;
	char env_cmdline, cmdline, *rootdev_input;
	char *allocated_suffix = NULL;
	char *allocated_rootdev = NULL;
	unsigned long rootdev_len;

	env_cmdline = env_get("bootargs");
	if (env_cmdline)
	*(current_chunk++) = env_cmdline;

	/* The \|slot_suffix\| needs to be passed to the kernel to know what
	* slot to boot from.
	*/
	if (slot_suffix) {
	allocated_suffix = malloc(strlen(ANDROID_ARG_SLOT_SUFFIX) +
	strlen(slot_suffix));
	strcpy(allocated_suffix, ANDROID_ARG_SLOT_SUFFIX);
	strcat(allocated_suffix, slot_suffix);
	*(current_chunk++) = allocated_suffix;
	}

	rootdev_input = env_get("android_rootdev");
	if (rootdev_input) {
	rootdev_len = strlen(ANDROID_ARG_ROOT) + CONFIG_SYS_CBSIZE + 1;
	allocated_rootdev = malloc(rootdev_len);
	strcpy(allocated_rootdev, ANDROID_ARG_ROOT);
	cli_simple_process_macros(rootdev_input,
	allocated_rootdev +
	strlen(ANDROID_ARG_ROOT));
	/* Make sure that the string is null-terminated since the
	* previous could not copy to the end of the input string if it
	* is too big.
	*/
	allocated_rootdev[rootdev_len - 1] = '\0';
	*(current_chunk++) = allocated_rootdev;
	}

	if (extra_args)
	*(current_chunk++) = extra_args;

	*(current_chunk++) = NULL;
	cmdline = strjoin(cmdline_chunks, ' ');
	free(allocated_suffix);
	free(allocated_rootdev);
	return cmdline;
	}

	int android_bootloader_boot_flow(struct blk_desc *dev_desc,
	const disk_partition_t *misc_part_info,
	const char *slot,
	unsigned long kernel_address)
	{
	enum android_boot_mode mode;
	disk_partition_t boot_part_info;
	int boot_part_num;
	int ret;
	char *command_line;
	char slot_suffix[3];
	const char *mode_cmdline = NULL;
	const char *boot_partition = ANDROID_PARTITION_BOOT;
	#ifdef CONFIG_ANDROID_SYSTEM_AS_ROOT
	int system_part_num
	disk_partition_t system_part_info;
	#endif

	/* Determine the boot mode and clear its value for the next boot if
	* needed.
	*/
	mode = android_bootloader_load_and_clear_mode(dev_desc, misc_part_info);
	printf("ANDROID: reboot reason: \"%s\"\n", android_boot_mode_str(mode));

	switch (mode) {
	case ANDROID_BOOT_MODE_NORMAL:
	#ifdef CONFIG_ANDROID_SYSTEM_AS_ROOT
	/* In normal mode, we load the kernel from "boot" but append
	* "skip_initramfs" to the cmdline to make it ignore the
	* recovery initramfs in the boot partition.
	*/
	mode_cmdline = "skip_initramfs";
	#endif
	break;
	case ANDROID_BOOT_MODE_RECOVERY:
	#ifdef CONFIG_ANDROID_SYSTEM_AS_ROOT
	/* In recovery mode we still boot the kernel from "boot" but
	* don't skip the initramfs so it boots to recovery.
	*/
	#else
	boot_partition = ANDROID_PARTITION_RECOVERY;
	#endif
	break;
	case ANDROID_BOOT_MODE_BOOTLOADER:
	/* Bootloader mode enters fastboot. If this operation fails we
	* simply return since we can't recover from this situation by
	* switching to another slot.
	*/
	return android_bootloader_boot_bootloader();
	}

	/* Look for an optional slot suffix override. */
	if (!slot \|\| !slot[0])
	slot = env_get("android_slot_suffix");

	slot_suffix[0] = '\0';
	if (slot && slot[0]) {
	slot_suffix[0] = '_';
	slot_suffix[1] = slot[0];
	slot_suffix[2] = '\0';
	} else {
	#ifdef CONFIG_ANDROID_AB
	bool normal_boot = (mode == ANDROID_BOOT_MODE_NORMAL);
	int slot_num = ab_select_slot(dev_desc, misc_part_info, normal_boot);
	if (slot_num < 0) {
	log_err("Could not determine Android boot slot.\n");
	return -1;
	}
	slot_suffix[0] = '_';
	slot_suffix[1] = BOOT_SLOT_NAME(slot_num);
	slot_suffix[2] = '\0';
	#endif
	}

	/* Load the kernel from the desired "boot" partition. */
	boot_part_num =
	android_part_get_info_by_name_suffix(dev_desc, boot_partition,
	slot_suffix, &boot_part_info);
	if (boot_part_num < 0)
	return -1;
	debug("ANDROID: Loading kernel from \"%s\", partition %d.\n",
	boot_part_info.name, boot_part_num);

	#ifdef CONFIG_ANDROID_SYSTEM_AS_ROOT
	system_part_num =
	android_part_get_info_by_name_suffix(dev_desc,
	ANDROID_PARTITION_SYSTEM,
	slot_suffix,
	&system_part_info);
	if (system_part_num < 0)
	return -1;
	debug("ANDROID: Using system image from \"%s\", partition %d.\n",
	system_part_info.name, system_part_num);
	#endif

	ret = android_image_load(dev_desc, &boot_part_info, kernel_address,
	-1UL);
	if (ret < 0)
	return ret;

	#ifdef CONFIG_ANDROID_SYSTEM_AS_ROOT
	/* Set Android root variables. */
	env_set_ulong("android_root_devnum", dev_desc->devnum);
	env_set_ulong("android_root_partnum", system_part_num);
	#endif
	env_set("android_slotsufix", slot_suffix);

	/* Assemble the command line */
	command_line = android_assemble_cmdline(slot_suffix, mode_cmdline);
	env_set("bootargs", command_line);

	debug("ANDROID: bootargs: \"%s\"\n", command_line);

	android_bootloader_boot_kernel(kernel_address);

	/* TODO: If the kernel doesn't boot mark the selected slot as bad. */
	return -1;
	}