xref: /rk3399_rockchip-uboot/cmd/boot_android.c (revision 36c449fe1f667af7b034680940bb8694b94b7e89)

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

#include <android_bootloader.h>
#include <android_avb/avb_version.h>
#include <android_avb/avb_ab_flow.h>
#include <android_avb/avb_ops_user.h>
#include <android_cmds.h>
#include <malloc.h>
#include <common.h>
#include <bootm.h>
#include <command.h>
#include <mp_boot.h>
#include <android_bootloader_message.h>
#include <android_avb/rk_avb_ops_user.h>
#include <android_avb/avb_atx_ops.h>

static int do_boot_android(cmd_tbl_t *cmdtp, int flag, int argc,
			   char * const argv[])
{
	unsigned long load_address;
	int ret = CMD_RET_SUCCESS;
	char *addr_arg_endp, *addr_str;
	struct blk_desc *dev_desc;

	if (argc < 3)
		return CMD_RET_USAGE;
	if (argc > 5)
		return CMD_RET_USAGE;

#ifdef CONFIG_MP_BOOT_BOOTM
	mpb_post(5);
#endif
	if (argc >= 5) {
		load_address = simple_strtoul(argv[4], &addr_arg_endp, 16);
		if (addr_arg_endp == argv[4] || *addr_arg_endp != '\0')
			return CMD_RET_USAGE;
	} else {
		addr_str = env_get("kernel_addr_r");
		if (addr_str)
			load_address = simple_strtoul(addr_str, NULL, 16);
		else
			load_address = CONFIG_SYS_LOAD_ADDR;
	}

#if defined(CONFIG_ARM64)
	/* ARM64 kernel load addr need to align to 0x80000, and android boot.img
	 * have a 2KB header, need to reserve space for it.
	 */
	load_address &= ~0x7ffff;
#endif

	dev_desc = blk_get_dev(argv[1], simple_strtoul(argv[2], NULL, 16));
	if (!dev_desc) {
		printf("Could not get %s %s\n", argv[1], argv[2]);
		return CMD_RET_FAILURE;
	}

	ret = android_bootloader_boot_flow(dev_desc, load_address);
	if (ret < 0) {
		printf("Android boot failed, error %d.\n", ret);
		return CMD_RET_FAILURE;
	}
	return CMD_RET_SUCCESS;
}

U_BOOT_CMD(
	boot_android, 5, 0, do_boot_android,
	"Execute the Android Bootloader flow.",
	"<interface> <dev[:part|;part_name]> <slot> [<kernel_addr>]\n"
	"    - Load the Boot Control Block (BCB) from the partition 'part' on\n"
	"      device type 'interface' instance 'dev' to determine the boot\n"
	"      mode, and load and execute the appropriate kernel.\n"
	"      In normal and recovery mode, the kernel will be loaded from\n"
	"      the corresponding \"boot\" partition. In bootloader mode, the\n"
	"      command defined in the \"fastbootcmd\" variable will be\n"
	"      executed.\n"
	"      On Android devices with multiple slots, the pass 'slot' is\n"
	"      used to load the appropriate kernel. The standard slot names\n"
	"      are 'a' and 'b'.\n"
	"    - If 'part_name' is passed, preceded with a ; instead of :, the\n"
	"      partition name whose label is 'part_name' will be looked up in\n"
	"      the partition table. This is commonly the \"misc\" partition.\n"
);

#ifdef CONFIG_ANDROID_AB
int do_avb_init_ab_metadata(cmd_tbl_t *cmdtp, int flag,
			    int argc, char * const argv[])
{
	AvbOps *ops;
	AvbABData ab_data;

	memset(&ab_data, 0, sizeof(AvbABData));
	debug("sizeof(AvbABData) = %d\n", (int)(size_t)sizeof(AvbABData));
	if (argc != 1)
		return CMD_RET_USAGE;

	ops = avb_ops_user_new();
	if (ops == NULL) {
		printf("avb_ops_user_new() failed!\n");
		return CMD_RET_FAILURE;
	}

	avb_ab_data_init(&ab_data);
	if (ops->ab_ops->write_ab_metadata(ops->ab_ops, &ab_data) != 0) {
		printf("do_avb_init_ab_metadata error!\n");
		avb_ops_user_free(ops);
		return CMD_RET_FAILURE;
	}

	printf("Initialize ab data to misc partition success.\n");
	avb_ops_user_free(ops);

	return CMD_RET_SUCCESS;
}

int do_avb_ab_mark_slot_active(cmd_tbl_t *cmdtp, int flag,
			       int argc, char * const argv[])
{
	AvbOps *ops;
	unsigned int slot_number;

	if (argc != 2)
		return CMD_RET_USAGE;

	ops = avb_ops_user_new();
	if (ops == NULL) {
		printf("avb_ops_user_new() failed!\n");
		return CMD_RET_FAILURE;
	}

	slot_number = simple_strtoul(argv[1], NULL, 16);
	if (avb_ab_mark_slot_active(ops->ab_ops, slot_number) != 0) {
		printf("avb_ab_mark_slot_active error!\n");
		avb_ops_user_free(ops);
		return CMD_RET_FAILURE;
	}

	printf("Mark slot %d active successfully.\n", slot_number);
	avb_ops_user_free(ops);

	return CMD_RET_SUCCESS;
}

int do_avb_ab_mark_slot_unbootable(cmd_tbl_t *cmdtp, int flag,
				   int argc, char * const argv[])
{
	AvbOps *ops;
	unsigned int slot_number;

	if (argc != 2)
		return CMD_RET_USAGE;

	ops = avb_ops_user_new();
	if (ops == NULL) {
		printf("avb_ops_user_new() failed!\n");
		return CMD_RET_FAILURE;
	}

	slot_number = simple_strtoul(argv[1], NULL, 16);
	if (avb_ab_mark_slot_unbootable(ops->ab_ops, slot_number) != 0) {
		printf("do_avb_ab_mark_slot_unbootable error!\n");
		avb_ops_user_free(ops);
		return CMD_RET_FAILURE;
	}

	printf("Mark slot %d unbootable successfully.\n", slot_number);
	avb_ops_user_free(ops);

	return CMD_RET_SUCCESS;
}

int do_avb_ab_mark_slot_successful(cmd_tbl_t *cmdtp, int flag,
				   int argc, char * const argv[])
{
	AvbOps *ops;
	unsigned int slot_number;

	if (argc != 2)
		return CMD_RET_USAGE;

	ops = avb_ops_user_new();
	if (ops == NULL) {
		printf("avb_ops_user_new() failed!\n");
		return CMD_RET_FAILURE;
	}

	slot_number = simple_strtoul(argv[1], NULL, 16);
	if (avb_ab_mark_slot_successful(ops->ab_ops, slot_number) != 0) {
		printf("do_avb_ab_mark_slot_successful error!\n");
		avb_ops_user_free(ops);
		return CMD_RET_FAILURE;
	}

	avb_ops_user_free(ops);

	return CMD_RET_SUCCESS;
}

int do_avb_read_ab_metadata(cmd_tbl_t *cmdtp, int flag,
			    int argc, char * const argv[])
{
	AvbOps *ops;
	AvbABData ab_data;

	if (argc != 1)
		return CMD_RET_USAGE;

	ops = avb_ops_user_new();
	if (ops == NULL) {
		printf("avb_ops_user_new() failed!\n");
		return CMD_RET_FAILURE;
	}

	if (ops->ab_ops->read_ab_metadata(ops->ab_ops, &ab_data) != 0) {
		printf("do_avb_write_ab_metadata error!\n");
		avb_ops_user_free(ops);
		return CMD_RET_FAILURE;
	}

	printf("Slot A information:\n");
	printf("slot A: priority = %d, tries_remaining = %d,\
	       successful_boot = %d\n",
	       ab_data.slots[0].priority,
	       ab_data.slots[0].tries_remaining,
	       ab_data.slots[0].successful_boot);
	printf("Slot B information:\n");
	printf("slot B: priority = %d, tries_remaining = %d,\
	       successful_boot = %d\n",
	       ab_data.slots[1].priority,
	       ab_data.slots[1].tries_remaining,
	       ab_data.slots[1].successful_boot);
	avb_ops_user_free(ops);

	return CMD_RET_SUCCESS;
}

int do_avb_write_ab_metadata(cmd_tbl_t *cmdtp, int flag,
			     int argc, char * const argv[])
{
	AvbOps *ops;
	AvbABData ab_data;

	if (argc != 1)
		return CMD_RET_USAGE;

	ops = avb_ops_user_new();
	if (ops == NULL) {
		printf("avb_ops_user_new() failed!\n");
		return CMD_RET_FAILURE;
	}

	if (ops->ab_ops->write_ab_metadata(ops->ab_ops, &ab_data) != 0) {
		printf("do_avb_write_ab_metadata error!\n");
		avb_ops_user_free(ops);
		return CMD_RET_FAILURE;
	}

	avb_ops_user_free(ops);

	return CMD_RET_SUCCESS;
}
#endif

#ifdef CONFIG_ANDROID_AVB
int do_avb_version(cmd_tbl_t *cmdtp, int flag, int argc,
		   char * const argv[])
{
	const char *avb_version;

	if (argc != 1)
		return CMD_RET_USAGE;

	avb_version = avb_version_string();
	printf("Android avb version is %s.\n", avb_version);

	return CMD_RET_SUCCESS;
}

int do_avb_read_rollback_index(cmd_tbl_t *cmdtp, int flag,
			       int argc, char * const argv[])
{
	AvbOps *ops;
	uint64_t out_rollback_index;
	size_t rollback_index_location;

	if (argc != 2)
		return CMD_RET_USAGE;

	ops = avb_ops_user_new();
	if (ops == NULL) {
		printf("avb_ops_user_new() failed!\n");
		return CMD_RET_FAILURE;
	}

	rollback_index_location = simple_strtoul(argv[1], NULL, 16);
	if (ops->read_rollback_index(ops, rollback_index_location,
				     &out_rollback_index) != 0) {
		printf("do_avb_read_rollback_index error!\n");
		avb_ops_user_free(ops);
		return CMD_RET_FAILURE;
	}

	printf("\nout_rollback_index = %llx\n", out_rollback_index);
	avb_ops_user_free(ops);

	return CMD_RET_SUCCESS;
}

int do_avb_write_rollback_index(cmd_tbl_t *cmdtp, int flag,
				int argc, char * const argv[])
{
	AvbOps *ops;
	uint64_t out_rollback_index;
	size_t rollback_index_location;

	if (argc != 3)
		return CMD_RET_USAGE;

	rollback_index_location = simple_strtoul(argv[1], NULL, 16);
	out_rollback_index = simple_strtoull(argv[2], NULL, 16);
	debug("out_rollback_index = %llx\n", out_rollback_index);
	ops = avb_ops_user_new();
	if (ops == NULL) {
		printf("avb_ops_user_new() failed!\n");
		return CMD_RET_FAILURE;
	}

	if (ops->write_rollback_index(ops, rollback_index_location,
				      out_rollback_index) != 0) {
		printf("do_avb_write_rollback_index error!\n");
		avb_ops_user_free(ops);
		return CMD_RET_FAILURE;
	}

	printf("\nWrite  rollback index successfully.\n");
	avb_ops_user_free(ops);

	return CMD_RET_SUCCESS;
}

int do_avb_read_is_device_unlocked(cmd_tbl_t *cmdtp, int flag,
				   int argc, char * const argv[])
{
	AvbOps *ops;
	bool out_is_unlocked;

	if (argc != 1)
		return CMD_RET_USAGE;

	ops = avb_ops_user_new();
	if (ops == NULL) {
		printf("avb_ops_user_new() failed!\n");
		return CMD_RET_FAILURE;
	}

	if (ops->read_is_device_unlocked(ops, &out_is_unlocked) != 0) {
		printf("do_avb_read_is_device_unlocked error!\n");
		avb_ops_user_free(ops);
		return CMD_RET_FAILURE;
	}

	printf("\n The device is %s\n",
		out_is_unlocked ? "UNLOCKED" : "LOCKED");
	avb_ops_user_free(ops);

	return CMD_RET_SUCCESS;
}
int do_avb_write_is_device_unlocked(cmd_tbl_t *cmdtp, int flag,
				    int argc, char * const argv[])
{
	AvbOps *ops;
	bool out_is_unlocked;

	if (argc != 2)
		return CMD_RET_USAGE;

	out_is_unlocked = simple_strtoul(argv[1], NULL, 16);
	if ((out_is_unlocked != 0) && (out_is_unlocked != 1))
		printf("enter out_is_unlocked value must is '0' or '1'\n");

	ops = avb_ops_user_new();
	if (ops == NULL) {
		printf("avb_ops_user_new() failed!\n");
		return CMD_RET_FAILURE;
	}

	if (ops->write_is_device_unlocked(ops, &out_is_unlocked) != 0) {
		printf("do_avb_write_is_device_unlocked error!\n");
		avb_ops_user_free(ops);
		return CMD_RET_FAILURE;
	}

	debug("out_is_unlocked = %d\n", out_is_unlocked);
	avb_ops_user_free(ops);

	return CMD_RET_SUCCESS;
}

int do_avb_get_size_of_partition(cmd_tbl_t *cmdtp, int flag,
				 int argc, char * const argv[])
{
	AvbOps *ops;
	char *requested_partitions;
	uint64_t out_size_in_bytes;

	if (argc != 2)
		return CMD_RET_USAGE;

	requested_partitions = argv[1];
	ops = avb_ops_user_new();
	if (ops == NULL) {
		printf("avb_ops_user_new() failed!\n");
		return CMD_RET_FAILURE;
	}

	if (ops->get_size_of_partition(ops, requested_partitions,
				       &out_size_in_bytes) != 0) {
		printf("Can not get %s partition size!\n", requested_partitions);
		avb_ops_user_free(ops);
		return CMD_RET_FAILURE;
	}

	printf("%s partition size = 0x%llx\n", requested_partitions,
	       out_size_in_bytes);
	avb_ops_user_free(ops);

	return CMD_RET_SUCCESS;
}

int do_avb_get_get_unique_guid_for_partition(cmd_tbl_t *cmdtp, int flag,
					     int argc, char * const argv[])
{
	AvbOps *ops;
	char *requested_partitions;
	size_t guid_buf_size = 37;
	char guid_buf[37];

	if (argc != 2)
		return CMD_RET_USAGE;

	requested_partitions = argv[1];
	ops = avb_ops_user_new();
	if (ops == NULL) {
		printf("avb_ops_user_new() failed!\n");
		return CMD_RET_FAILURE;
	}

	if (ops->get_unique_guid_for_partition(ops, requested_partitions,
					       guid_buf, guid_buf_size) != 0) {
		printf("Can not get %s partition UUID!\n",
		       requested_partitions);
		avb_ops_user_free(ops);
		return CMD_RET_FAILURE;
	}

	printf("%s partition UUID is %s\n", requested_partitions, guid_buf);
	avb_ops_user_free(ops);

	return CMD_RET_SUCCESS;
}

int do_avb_read(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
	AvbOps *ops;
	char *requested_partitions;
	int64_t offset_blk;
	size_t blkcnt;
	size_t out_num_read;
	int i;
	char *buffer;

	if (argc != 4)
		return CMD_RET_USAGE;

	requested_partitions = argv[1];
	offset_blk = simple_strtoul(argv[2], NULL, 16);
	blkcnt = simple_strtoul(argv[3], NULL, 16);
	ops = avb_ops_user_new();
	buffer = (char *)malloc(blkcnt * 512);
	if (buffer == NULL)
		printf("malloc buffer failed!\n");

	if (ops == NULL) {
		printf("avb_ops_user_new() failed!\n");
		return CMD_RET_FAILURE;
	}

	if (ops->read_from_partition(ops, requested_partitions,
				     offset_blk, blkcnt, buffer,
				     &out_num_read) != 0) {
		printf("do avb read error!\n");
		free(buffer);
		avb_ops_user_free(ops);
		return CMD_RET_FAILURE;
	}

	for (i = 0; i < 512 * blkcnt; i++) {
		printf("buffer %d = %x", i, buffer[i]);
		if ((i + 1) % 4 == 0)
			printf("\n");
	}

	free(buffer);
	avb_ops_user_free(ops);

	return CMD_RET_SUCCESS;
}

int do_perm_attr_test(cmd_tbl_t *cmdtp, int flag,
		      int argc, char * const argv[])
{
	AvbOps *ops;
	int i;
	uint8_t hash[AVB_SHA256_DIGEST_SIZE];

	if (argc != 1)
		return CMD_RET_USAGE;

	ops = avb_ops_user_new();
	if (ops == NULL) {
		printf("avb_ops_user_new() failed!\n");
		return CMD_RET_FAILURE;
	}

	if (ops->atx_ops->read_permanent_attributes_hash(ops->atx_ops, hash) != 0) {
		printf("read_permanent_attributes_hash error!\n");
		avb_ops_user_free(ops);
		return CMD_RET_FAILURE;
	}

	for (i = 0; i < AVB_SHA256_DIGEST_SIZE; i++) {
		if (i % 4 == 0)
			printf("\n");
		printf("0x%x  ", hash[i]);
	}

	avb_ops_user_free(ops);

	return CMD_RET_SUCCESS;
}

int do_avb_verify_partition(cmd_tbl_t *cmdtp, int flag,
			    int argc, char * const argv[])
{
	AvbOps *ops;
	const char *requested_partitions[1];
	const char * slot_suffixes[2] = {"_a", "_b"};
	AvbSlotVerifyFlags flags;
	AvbSlotVerifyData *slot_data[2] = {NULL, NULL};
	AvbSlotVerifyResult verify_result;
	size_t n;

	if (argc != 3)
		return CMD_RET_USAGE;

	requested_partitions[0] = argv[1];
	n = simple_strtoul(argv[2], NULL, 16);
	ops = avb_ops_user_new();
	flags = AVB_SLOT_VERIFY_FLAGS_NONE;
	verify_result =
		avb_slot_verify(ops,
				requested_partitions,
				slot_suffixes[n],
				flags,
				AVB_HASHTREE_ERROR_MODE_RESTART_AND_INVALIDATE,
				&slot_data[n]);
	if (verify_result != 0)
		return CMD_RET_FAILURE;

	avb_ops_user_free(ops);

	return CMD_RET_SUCCESS;
}
#endif

static cmd_tbl_t cmd_avb[] = {
#ifdef CONFIG_ANDROID_AB
	U_BOOT_CMD_MKENT(init, 1, 1, do_avb_init_ab_metadata, "", ""),
	U_BOOT_CMD_MKENT(slot_active, 2, 1,
			 do_avb_ab_mark_slot_active, "", ""),
	U_BOOT_CMD_MKENT(slot_unbootable, 2, 1,
			 do_avb_ab_mark_slot_unbootable, "", ""),
	U_BOOT_CMD_MKENT(slot_successful, 2, 1,
			 do_avb_ab_mark_slot_successful, "", ""),
	U_BOOT_CMD_MKENT(readabmisc, 1, 1, do_avb_read_ab_metadata, "", ""),
#endif
#ifdef CONFIG_ANDROID_AVB
	U_BOOT_CMD_MKENT(version, 1, 1, do_avb_version, "", ""),
	U_BOOT_CMD_MKENT(read_rollback, 2, 1,
			 do_avb_read_rollback_index, "", ""),
	U_BOOT_CMD_MKENT(write_rollback, 3, 1,
			 do_avb_write_rollback_index, "", ""),
	U_BOOT_CMD_MKENT(read_lock_status, 1, 1,
			 do_avb_read_is_device_unlocked, "", ""),
	U_BOOT_CMD_MKENT(write_lock_status, 2, 1,
			 do_avb_write_is_device_unlocked, "", ""),
	U_BOOT_CMD_MKENT(part_size, 2, 1,
			 do_avb_get_size_of_partition, "", ""),
	U_BOOT_CMD_MKENT(part_guid, 2, 1,
			 do_avb_get_get_unique_guid_for_partition, "", ""),
	U_BOOT_CMD_MKENT(read, 4, 1, do_avb_read, "", ""),
	U_BOOT_CMD_MKENT(perm_attr_test, 1, 1, do_perm_attr_test, "", ""),
	U_BOOT_CMD_MKENT(verify, 3, 1, do_avb_verify_partition, "", ""),
#endif
};

static int do_boot_avb(cmd_tbl_t *cmdtp,
		       int flag,
		       int argc,
		       char * const argv[])
{
	cmd_tbl_t *cp;

	cp = find_cmd_tbl(argv[1], cmd_avb, ARRAY_SIZE(cmd_avb));

	argc--;
	argv++;

	if (cp == NULL || argc > cp->maxargs)
		return CMD_RET_USAGE;
	if (flag == CMD_FLAG_REPEAT && !cp->repeatable)
		return CMD_RET_SUCCESS;

	return cp->cmd(cmdtp, flag, argc, argv);
}

U_BOOT_CMD(
	bootavb, 29, 1, do_boot_avb,
	"Execute the Android avb a/b boot flow.",
	"init - initialize the avbabmeta\n"
	"bootavb version - display info of bootavb version\n"
	"bootavb slot_active cnt\n"
	"bootavb slot_unbootable cnt\n"
	"bootavb slot_successful cnt\n"
	"bootavb read_rollback rollback_index_location\n"
	"bootavb write_rollback rollback_index_location rollback_index\n"
	"bootavb read_lock_status\n"
	"bootavb write_lock_status 0 or 1\n"
	"bootavb part_size partitions_name\n"
	"bootavb part_guid partitions_name\n"
	"bootavb read partition offset_blk cnt\n"
	"bootavb readabmisc\n"
	"bootavb perm_attr_test\n"
	"bootavb verify partition slot_cnt;partion name without '_a' or '_b'\n"
);