android13/u-boot/cmd/tftp_update.c

/*
 * (C) Copyright 2021 Rockchip Electronics Co., Ltd.
 *
 * SPDX-License-Identifier:     GPL-2.0+
 */

#include <common.h>
#include <boot_rkimg.h>
#include <crypto.h>
#include <dm.h>
#include <sysmem.h>
#include <u-boot/sha256.h>
#ifdef CONFIG_ANDROID_AB
#include <android_avb/avb_ops_user.h>
#include <android_avb/rk_avb_ops_user.h>
#endif
#include <asm/arch/vendor.h>

DECLARE_GLOBAL_DATA_PTR;

#define TFTPUD_I(fmt, args...)	printf("[TFTPUD]: "fmt, ##args)
#define TFTPUD_E(fmt, args...)	printf("[TFTPUD-ERROR]: "fmt, ##args)

#define UPDATE_HDR_FILE		"update.hdr"
#define GPT_ENV_FILE		"gpt_env.txt"
#define MAX_UPDATE_HEADER_SIZE	SZ_128K
#define MAX_REMAIN_TRIES	3
#define SHA256_HASH_SIZE	32

struct update_header {
	struct list_head images;
	void *shared_buf;
	u32 version;
	u32 rollback_idx;
	u32 lba_step;
	u32 mb;
	int force_update;
	const char *spec_partition;
};

struct local_information {
	u32 version;
	u32 rollback_idx;
	char current_slot[3];
};

struct image_element {
	char file_name[32];
	char part_name[32];
	void *buf;
	u32 size;	/* uint: byte */
	u32 lba_start;
	u32 lba_offset;
	u32 lba_cnt;
	u8 remain_tries;
	int hash_noffset;
	struct list_head node;
};

static struct update_header update_hdr;
static struct local_information local_info;
static const char *server_dir;

static int tftpfw_version_set(u32 version)
{
	int ret;

	ret = vendor_storage_write(FIRMWARE_VER_ID, &version, sizeof(version));

	return ret < 0 ? ret : 0;
}

static u32 tftpfw_version_get(void)
{
	u32 version;
	int ret;

	ret = vendor_storage_read(FIRMWARE_VER_ID, &version, sizeof(version));
	if (ret < 0) {
		if (ret == -EINVAL) {
			version = 0; /* first initial as 0 */
			TFTPUD_I("Initial firmware version as 0\n");
			ret = tftpfw_version_set(version);
			if (ret < 0)
				return ret;
		} else {
			return ret;
		}
	}

	return version;
}

static int tftp_download(void *addr, const char *file)
{
	char tftp_cmd[64];

	if (server_dir)
		snprintf(tftp_cmd, 64, "tftp 0x%lx %s/%s",
				(ulong)addr, server_dir, file);
	else
		snprintf(tftp_cmd, 64, "tftp 0x%lx %s", (ulong)addr, file);

	return run_command(tftp_cmd, 0);
}

static void update_cleanup(void *fit, struct update_header *hdr)
{
	struct image_element *e;
	struct list_head *node;

	list_for_each(node, &hdr->images) {
		e = list_entry(node, struct image_element, node);
		free(e);
	}

	if (hdr->shared_buf)
		free(hdr->shared_buf);
	if (fit)
		free(fit);
}

static inline int is_gpt(const char *name)
{
	if (!name)
		return 0;

	return !strcmp(name, GPT_ENV_FILE);
}

static int update_populate_image(void *fit, struct update_header *hdr)
{
	struct blk_desc *dev_desc;
	struct image_element *e;
	disk_partition_t part;
	const char *name, *dp;
	const char *noseq_name;
	char *last_part_name = NULL;
	uint last_lba_offset = 0;
	uint lba_offset;
	int images, noffset;
	int ret;

	images = fdt_path_offset(fit, FIT_IMAGES_PATH);
	if (images < 0)
		return images;

	dev_desc = rockchip_get_bootdev();
	if (!dev_desc)
		return -ENODEV;

	fdt_for_each_subnode(noffset, fit, images) {
		name = fit_get_name(fit, noffset, NULL);
		printf("# %s:\n", name);

		if (is_gpt(name))
			continue;

		e = malloc(sizeof(*e));
		if (!e)
			return -ENOMEM;

		e->remain_tries = MAX_REMAIN_TRIES;
		e->buf = hdr->shared_buf;
		e->size = fdtdec_get_uint(fit, noffset, "data-size", -ENODATA);
		if (e->size == -ENODATA)
			return -ENODATA;

		/* part name */
		strcpy(e->file_name, name);
		strcat(e->file_name, ".part.img");
		noseq_name = strstr(name, "-");
		if (!noseq_name)
			return -EINVAL;
		noseq_name++;
		dp = strstr(noseq_name, "-");
		if (!dp)
			return -EINVAL;
		dp++;
		strlcpy(e->part_name, noseq_name, strlen(noseq_name) - strlen(dp));
		ret = part_get_info_by_name_strict(dev_desc, e->part_name, &part);
		if (ret < 0) {
			TFTPUD_E("No partition '%s'\n", e->part_name);
			return -EINVAL;
		}

		/* lba */
		if (!strcmp(last_part_name, e->part_name))
			lba_offset = last_lba_offset + hdr->lba_step;
		else
			lba_offset = 0;

		e->lba_start = part.start;
		e->lba_offset = lba_offset;
		e->lba_cnt = DIV_ROUND_UP(e->size, 512);
		e->hash_noffset = fdt_subnode_offset(fit, noffset, "hash");
		if (e->hash_noffset < 0)
			return e->hash_noffset;

		list_add_tail(&e->node, &hdr->images);
		last_part_name = e->part_name;
		last_lba_offset = lba_offset;

		printf("            file: %s\n", e->file_name);
		printf("       partition: %s\n", e->part_name);
		printf("             buf: 0x%08lx\n", (ulong)e->buf);
		printf("            size: 0x%08x\n", e->size);
		printf("       lba_start: 0x%08x\n", e->lba_start);
		printf("      lba_offset: 0x%08x\n", e->lba_offset);
		printf("         lba_cnt: 0x%08x\n", e->lba_cnt);
		printf("    remain_tries: %d\n", e->remain_tries);
		printf("    hash_noffset: 0x%08x\n\n", e->hash_noffset);
	}

	return 0;
}

static void *update_download_hdr(struct update_header *hdr)
{
	u32 filesz;
	void *fit;

	fit = memalign(ARCH_DMA_MINALIGN, MAX_UPDATE_HEADER_SIZE);
	if (!fit)
		return NULL;

	if (tftp_download(fit, UPDATE_HDR_FILE)) {
		free(fit);
		return NULL;
	}

	if (fdt_check_header(fit)) {
		TFTPUD_E("invalid update hdr magic\n");
		free(fit);
		return NULL;
	}

	/* sha256 csum was appended at the end of update.hdr */
	filesz = env_get_ulong("filesize", 16, 0);
	if ((fdt_totalsize(fit) + SHA256_HASH_SIZE) != filesz) {
		TFTPUD_E("invalid sha256 hash at the tail of hdr\n");
		return NULL;
	}

	return fit;
}

#ifndef CONFIG_FIT_SIGNATURE
#ifdef CONFIG_DM_CRYPTO
static void sha256_checksum(char *input, u32 input_len, u8 *output)
{
	sha_context csha_ctx;
	struct udevice *dev;

	dev = crypto_get_device(CRYPTO_SHA256);
	if (!dev) {
		TFTPUD_E("No crypto device\n");
		return;
	}
	csha_ctx.algo = CRYPTO_SHA256;
	csha_ctx.length = input_len;
	crypto_sha_csum(dev, &csha_ctx, (char *)input, input_len, output);
}
#else
static void sha256_checksum(char *input, u32 input_len, u8 *output)
{
	sha256_csum((const uchar *)input, input_len, output);
}
#endif

static int hdr_checksum_verify(void *fit, struct update_header *hdr)
{
	u8 *hash, csum[SHA256_HASH_SIZE];
	int ret, i;

	hash = (u8 *)fit + fdt_totalsize(fit);
	sha256_checksum(fit, fdt_totalsize(fit), csum);
	ret = memcmp(hash, csum, SHA256_HASH_SIZE) ? -EINVAL : 0;
	if (ret) {
		printf(" update.hash: ");
		for (i = 0; i < SHA256_HASH_SIZE; i++)
			printf("%02x", hash[i]);
		printf("\n");

		printf(" calculate hash: ");
		for (i = 0; i < SHA256_HASH_SIZE; i++)
			printf("%02x", csum[i]);
		printf("\n");
	}

	return ret;
}
#endif

static void print_hdr_local(struct update_header *hdr,
			    struct local_information *local)
{
	printf("# Server:\n");
	printf("         version: %d\n", hdr->version);
	printf("    rollback_idx: %d\n", hdr->rollback_idx);
	printf("    force_update: %d\n", hdr->force_update);
	printf("              MB: %d\n", hdr->mb);
	printf("        lba_step: 0x%08x\n", hdr->lba_step);
	printf("      shared_buf: 0x%08lx - 0x%08lx\n",
	       (ulong)hdr->shared_buf, (ulong)hdr->shared_buf + hdr->mb * SZ_1M);
	printf("  spec_partition: %s\n\n", hdr->spec_partition);

	printf("# Local:\n");
	printf("         version: %d\n", local->version);
	printf("    rollback_idx: %d\n", local->rollback_idx);
	printf("    current_slot: %s\n", local->current_slot);
	printf("\n");
}

static int hdr_param_verify(void *fit, struct update_header *hdr,
			    struct local_information *local, int conf)
{
	u32 size;
	int ret;

	/* remote */
	hdr->version = fdtdec_get_uint(fit, 0, "version", 0);
	hdr->rollback_idx = fdtdec_get_uint(fit, conf, "rollback-index", 0);
	hdr->force_update = fdtdec_get_uint(fit, conf, "force_update", 0);
	hdr->mb = fdtdec_get_uint(fit, conf, "image-size-MB", 0);
	size = hdr->mb * SZ_1M;
	hdr->lba_step = size / 512;
	/* TODO: use sysmem alloc/free */
	hdr->shared_buf = malloc(size);
	if (!hdr->shared_buf)
		return -ENOMEM;

	/* local */
	ret = tftpfw_version_get();
	if (ret < 0) {
		TFTPUD_E("Failed to get local firmware version, ret=%d\n", ret);
		return local->version;
	}
	local->version = ret;
#ifdef CONFIG_FIT_ROLLBACK_PROTECT
	u32 remote_rollback_idx;

	ret = fit_rollback_index_verify(fit, FIT_ROLLBACK_INDEX,
					&remote_rollback_idx, &local->rollback_idx);
	if (ret) {
		TFTPUD_E("Failed to get local rollback-index, ret=%d\n", ret);
		return ret;
	}
#else
	local->rollback_idx = -1;
#endif
#ifdef CONFIG_ANDROID_AB
	ret = rk_avb_get_current_slot(local->current_slot);
	if (ret) {
		TFTPUD_E("Failed to get local current slot, ret=%d\n", ret);
		return ret;
	}
#else
	strcpy(local->current_slot, "-");
#endif

	print_hdr_local(hdr, local);

	/* verify */
	if (hdr->force_update) {
		TFTPUD_I("Remote requires force upgrade !\n");
		return 0;
	}
	if (hdr->version < local->version) {
		TFTPUD_E("Invalid firmware version: %d(remote) < %d(local)\n",
			 hdr->version, local->version);
		return -EINVAL;
	}
#ifdef CONFIG_FIT_ROLLBACK_PROTECT
	if (remote_rollback_idx < local->rollback_idx) {
		TFTPUD_E("Invalid rollback-index: %d(remote) < %d(local)\n",
			 remote_rollback_idx, local->rollback_idx);
		return -EINVAL;
	}
#endif

	return 0;
}

static int update_verify_hdr(void *fit, struct update_header *hdr,
			     struct local_information *local)
{
	const char *name;
	int noffset;
	int conf;
	int ret;

	noffset = fdt_path_offset(fit, FIT_CONFS_PATH);
	name = fdt_getprop(fit, noffset, "default", NULL);
	conf = fdt_subnode_offset(fit, noffset, name);
	if (conf < 0)
		return conf;

#ifdef CONFIG_FIT_SIGNATURE
	/* Secure: verify signature */
	ret = fit_config_verify(fit, conf);
	if (ret)
		return ret;

	TFTPUD_I("hdr signature verified\n");
#else
	/* Non-secure: verify hash */
	ret = hdr_checksum_verify(fit, hdr);
	if (ret)
		return ret;

	TFTPUD_I("hdr checksum verified\n");
#endif
	/* verify rollback index ..., etc */
	ret = hdr_param_verify(fit, hdr, local, conf);
	if (ret)
		return ret;

	TFTPUD_I("hdr param verified\n");

	return 0;
}

static int update_local_info(void *fit, struct update_header *hdr)
{
	int ret;

	TFTPUD_I("Update local information... ");

	ret = tftpfw_version_set(hdr->version);
	if (ret) {
		TFTPUD_E("Update local param FAIL, ret=%d\n", ret);
		return ret;
	}
	printf("fw_version=%d ", hdr->version);

#ifdef CONFIG_FIT_ROLLBACK_PROTECT
	ret = fit_write_trusty_rollback_index(hdr->rollback_idx);
	if (ret)
		return ret;
	printf("rollback_idx=%d ", hdr->rollback_idx);
#endif
	printf("\n");

	return 0;
}

static int update_ignore_image(void *fit, struct update_header *hdr,
			       struct image_element *e)
{
#ifdef CONFIG_ANDROID_AB
	char *slot_suffix;

	/* Android A/B skip current slot */
	slot_suffix = (char *)e->part_name + strlen(e->part_name) - 2;
	if (!strcmp(hdr->current_slot, slot_suffix))
		return 1;
#endif
	/* try to find expected target partition */
	if (hdr->spec_partition && strcmp(e->part_name, hdr->spec_partition))
		return 1;

	return 0;
}

static int download_image(void *fit, struct image_element *e)
{
	ulong fileaddr;
	ulong filesize;
	char *msg = "";
	int ret;

	/* download */
	printf("[TFTPUD-0]: download \"%s\" at 0x%lx\n",
	       e->file_name, (ulong)e->buf);

	ret = tftp_download(e->buf, e->file_name);
	if (ret)
		return ret;

	fileaddr = env_get_ulong("fileaddr", 16, 0);
	filesize = env_get_ulong("filesize", 16, 0);
	if (!fileaddr || !filesize) {
		TFTPUD_E("No fileaddr and filesize\n");
		return -ENOENT;
	}

	if (filesize != e->size) {
		TFTPUD_E("Expected filesize 0x%08lx != 0x%08x\n", filesize, e->size);
		return -EINVAL;
	}

	/* verify */
	printf("[TFTPUD-1]: verify ");
	ret = fit_image_check_hash(fit, e->hash_noffset, e->buf, e->size, &msg);
	printf("[%s]\n", ret ? "-" : "+");

	return ret;
}

static int update_flash_image(struct image_element *e)
{
	struct blk_desc *dev_desc;
	int ret;

	dev_desc = rockchip_get_bootdev();
	if (!dev_desc) {
		TFTPUD_E("No boot device\n");
		return -ENODEV;
	}

	printf("[TFTPUD-2]: Flash to \"%s\" partition at LBA offset 0x%08x, "
	       "with 0x%08x sectors ... ",
	       e->part_name, e->lba_offset, e->lba_cnt);

	if (dev_desc->if_type == IF_TYPE_MTD) {
		dev_desc->op_flag |= BLK_MTD_CONT_WRITE;
		ret = blk_dwrite(dev_desc, e->lba_start + e->lba_offset,
				 e->lba_cnt, (void *)e->buf);
		dev_desc->op_flag &= ~(BLK_MTD_CONT_WRITE);
	} else {
		ret = blk_dwrite(dev_desc, e->lba_start + e->lba_offset,
				 e->lba_cnt, (void *)e->buf);
	}

	if (ret != e->lba_cnt)
		printf("Failed(%d)\n\n\n", ret);
	else
		printf("OK\n\n\n");

	return 0;
}

static int update_download_image(void *fit, struct image_element *e)
{
	int i, ret;

	for (i = 0; i < e->remain_tries; i++) {
		ret = download_image(fit, e);
		if (!ret)
			return 0;

		TFTPUD_E("retry-%d download\n", i);
		continue;
	}

	return -ENODATA;
}

static int update_write_gpt(void *fit, struct update_header *hdr)
{
	struct image_element *e;
	char *gpt_parts, *p;
	const char *name;
	int images;
	int noffset;
	int ret = 0;

	images = fdt_path_offset(fit, FIT_IMAGES_PATH);
	if (images < 0)
		return images;

	noffset = fdt_first_subnode(fit, images);
	if (noffset < 0)
		return noffset;

	/* gpt must be the 1st node */
	name = fit_get_name(fit, noffset, NULL);
	if (!is_gpt(name))
		return 0;

	e = malloc(sizeof(*e));
	if (!e)
		return -ENOMEM;

	e->remain_tries = MAX_REMAIN_TRIES;
	e->buf = hdr->shared_buf;
	e->size = fdtdec_get_uint(fit, noffset, "data-size", -ENODATA);
	if (e->size == -ENODATA) {
		ret = -EINVAL;
		goto out;
	}

	strcpy(e->file_name, name);
	e->hash_noffset = fdt_subnode_offset(fit, noffset, "hash");
	if (e->hash_noffset < 0)
		return e->hash_noffset;

	printf("\n# %s:\n", e->file_name);
	printf("             buf: 0x%08lx\n", (ulong)e->buf);
	printf("            size: 0x%08x\n", e->size);
	printf("    remain_tries: %d\n", e->remain_tries);
	printf("    hash_noffset: 0x%08x\n\n", e->hash_noffset);

	/* download */
	ret = update_download_image(fit, e);
	if (ret) {
		TFTPUD_E("\"%s\" download fail, ret=%d\n",
			 e->file_name, ret);
		goto out;
	}

	/* terminate gpt string */
	gpt_parts = (char *)e->buf;
	p = gpt_parts + e->size - 1;
	*p = '\0';

	/* write */
	printf("[TFTPUD-2]: Write gpt ...\n");
	printf("    %s\n\n", gpt_parts);
	env_set("gpt_parts", gpt_parts);
	ret = run_command("gpt write ${devtype} ${devnum} ${gpt_parts}", 0);
	if (ret) {
		printf("Failed to write gpt\n");
		ret = -EIO;
		goto out;
	}
	ret = run_command("gpt verify ${devtype} ${devnum} ${gpt_parts}", 0);
	if (ret) {
		printf("Failed to verify gpt\n");
		ret = -EIO;
		goto out;
	}
	printf("\n");
out:
	free(e);

	return ret;
}

static int do_tftp_full_update(cmd_tbl_t *cmdtp, int flag,
			       int argc, char * const argv[])
{
	struct local_information *local = &local_info;
	struct update_header *hdr = &update_hdr;
	struct image_element *e;
	struct list_head *node;
	const char *dir_part_str;
	const char *part_str;
	const char *dir_str;
	char *dup_str = NULL;
	u32 total_success = 0;
	u32 total_traverse = 0;
	ulong start_ms;
	ulong total_ms;
	void *fit;
	int ret;

	start_ms = get_timer(0);
	memset(hdr, 0, sizeof(*hdr));
	memset(local, 0, sizeof(*local));

	/* only handle a single partititon ? */
	if (argc > 1) {
		dir_part_str = argv[1];
		part_str = strchr(dir_part_str, ':');
		if (part_str) {
			/*
			 * eg: tftpupdate image:recovery
			 *     tftpupdate image:*
			 *     tftpupdate image:
			 */
			dup_str = strdup(dir_part_str);
			dup_str[part_str - dir_part_str] = 0;
			dir_str = dup_str;
			part_str++;
			if (*part_str == '*')
				part_str = NULL;
		} else {
			/* eg: tftpupdate recovery */
			dir_str = NULL;
			part_str = argv[1];
		}
	} else {
		dir_str = NULL;
		part_str = NULL;
	}

	server_dir = dir_str;
	hdr->spec_partition = part_str;
	INIT_LIST_HEAD(&hdr->images);

	fit = update_download_hdr(hdr);
	if (!fit) {
		TFTPUD_E("download hdr fail\n");
		ret = -EINVAL;
		goto out;
	}

	ret = update_verify_hdr(fit, hdr, local);
	if (ret) {
		TFTPUD_E("verify hdr fail, ret=%d\n", ret);
		goto out;
	}

	/* flash gpt table early than any other partition */
	ret = update_write_gpt(fit, hdr);
	if (ret) {
		TFTPUD_E("write gpt fail, ret=%d\n", ret);
		goto out;
	}

	ret = update_populate_image(fit, hdr);
	if (ret) {
		TFTPUD_E("populate image fail, ret=%d\n", ret);
		goto out;
	}

	list_for_each(node, &hdr->images) {
		e = list_entry(node, struct image_element, node);
		total_traverse++;

		/* ignore ? */
		if (update_ignore_image(fit, hdr, e))
			continue;

		ret = update_download_image(fit, e);
		if (ret) {
			TFTPUD_E("\"%s\" download fail, ret=%d\n",
				 e->file_name, ret);
			goto out;
		}

		ret = update_flash_image(e);
		if (ret) {
			TFTPUD_E("\"%s\" flash fail, ret=%d\n",
				 e->file_name, ret);
			goto out;
		}

		total_success++;
	}

	if (total_success == 0) {
		if (hdr->spec_partition) {
			TFTPUD_E("No %s partition was found\n", hdr->spec_partition);
			ret = CMD_RET_FAILURE;
		}
		goto out;
	}

	/* If this is full upgrade, update local info */
	if (!hdr->spec_partition)
		update_local_info(fit, hdr);
out:
	update_cleanup(fit, hdr);
	if (!ret) {
		total_ms = get_timer(start_ms);
		TFTPUD_I("tftpupdate is OK (total time: %lds, upgrade: %d/%d), "
			 "system reboot is recommend\n",
			 total_ms / 1000, total_success, total_traverse);
	}

	return ret ? CMD_RET_FAILURE : CMD_RET_SUCCESS;
}

U_BOOT_CMD(
	tftp_full_update, 2, 1, do_tftp_full_update,
	"Update a set of images organized with FIT via network using TFTP protocol",
	"[[server-dir:][partition]"
);