board/khadas/kvim3/zircon.c - u-boot - Git at Google

 /*
  * Copyright (c) 2018 The Fuchsia Authors
  *
  * SPDX-License-Identifier:	BSD-3-Clause
  */

 #include <aml_i2c.h>
 #include <asm/arch/secure_apb.h>
 #include <asm/global_data.h>
 #include <common.h>
 #include <emmc_partitions.h>
 #include <g_dnl.h>
 #include <inttypes.h>
 #include <lib/zbi/zbi.h>
 #include <lib/zbi-format/board.h>
 #include <lib/zbi-format/cpu.h>
 #include <lib/zbi-format/memory.h>
 #include <libfdt.h>
 #include <part.h>
 #include <zircon.h>

 #define PDEV_VID_KHADAS 4
 #define PDEV_PID_VIM2 2
 #define PDEV_PID_VIM3 3

 #define NVRAM_LENGTH (16 * 1024)

 #define CMDLINE_ENTROPY_SIZE 1024
 #define CMDLINE_ENTROPY_BITS 256 // random bits to pass to zircon.

 #define ENTROPY_BITS_PER_CHAR 4

 DECLARE_GLOBAL_DATA_PTR;

 static char entropy_cmdline[CMDLINE_ENTROPY_SIZE] = { 0 };
 static const char zircon_entropy_arg[] = "kernel.entropy-mixin=";

 #define static_assert _Static_assert
 static_assert(CMDLINE_ENTROPY_BITS % 32 == 0,
 	      "Requested entropy must be a multiple of 32");

 static_assert((CMDLINE_ENTROPY_BITS / ENTROPY_BITS_PER_CHAR) +
 			      sizeof(zircon_entropy_arg) <
 		      CMDLINE_ENTROPY_SIZE,
 	      "Requested entropy doesn't fit in cmdline.");

 static const char BOOTLOADER_VERSION[] = "zircon-bootloader=0.12";

 static zbi_mem_range_t mem_config[] = {
 	{
 		.type = ZBI_MEM_TYPE_RAM,
 		.length = 0x80000000,
 	},
 	{
 		.type = ZBI_MEM_TYPE_PERIPHERAL,
 		.paddr = 0xfe000000,
 		.length = 0x02000000,
 	},
 	{
 		.type = ZBI_MEM_TYPE_RESERVED,
 		.paddr = 0x07400000,
 		.length = 0x00100000,
 	},
 	{
 		.type = ZBI_MEM_TYPE_RESERVED,
 		.paddr = 0x05000000,
 		.length = 0x02300000,
 	},
 };

 static const zbi_dcfg_simple_t uart_driver = {
 	.mmio_phys = 0xff803000,
 	.irq = 225,
 };

 static const zbi_dcfg_arm_gic_v2_driver_t gicv2_driver = {
 	.mmio_phys = 0xffc00000,
 	.gicd_offset = 0x1000,
 	.gicc_offset = 0x2000,
 	.gich_offset = 0x4000,
 	.gicv_offset = 0x6000,
 	.ipi_base = 5,
 };

 static const zbi_dcfg_arm_psci_driver_t psci_driver = {
 	.use_hvc = false,
 	.reboot_args = { 1, 0, 0 },
 	.reboot_bootloader_args = { 4, 0, 0 },
 	.reboot_recovery_args = { 2, 0, 0 },
 };

 static const zbi_dcfg_arm_generic_timer_driver_t timer_driver = {
 	.irq_phys = 30,
 };

 static const zbi_platform_id_t platform_id = {
 	.vid = PDEV_VID_KHADAS,
 	.pid = PDEV_PID_VIM3,
 	.board_name = "vim3",
 };

 enum {
 	PART_BOOTLOADER,
 	PART_ZIRCON_A,
 	PART_ZIRCON_B,
 	PART_ZIRCON_R,
 	PART_SYS_CONFIG,
 	PART_FACTORY_CONFIG,
 	PART_FVM,
 	PART_COUNT,
 };

 extern int dtb_read(void *addr);

 zbi_result_t add_zbi_item_or_log(void *zbi, size_t capacity, uint32_t type,
 				 uint32_t extra, const void *payload,
 				 size_t payload_length, const char *format, ...)
 {
 	zbi_result_t result = zbi_create_entry_with_payload(
 		zbi, capacity, type, extra, 0, payload, payload_length);
 	if (result != ZBI_RESULT_OK) {
 		va_list args;
 		va_start(args, format);
 		vprintf(format, args);
 		va_end(args);
 	}
 	return result;
 }

 static zbi_result_t add_serial_number(zbi_header_t *zbi, size_t capacity)
 {
 	// Serial number from secure storage takes priority, if it exists.
 	// Otherwise use the "serial" env var.
 	// TODO: we may want to unify this logic with the fastboot logic to
 	// make sure they stay in sync.
 	const char *s = get_usid_string();
 	if (!s) {
 		s = getenv("serial");
 	}
 	if (!s || (*s == '\0')) {
 		printf("Failed to retrieve serial number\n");
 		return ZBI_RESULT_ERROR;
 	}

 	return add_zbi_item_or_log(
 		zbi, capacity, ZBI_TYPE_SERIAL_NUMBER, 0, s, strlen(s),
 		"Failed to add ZBI entry for serial number\n");
 }

 static zbi_result_t add_board_info(zbi_header_t *zbi, size_t capacity)
 {
 	zbi_board_info_t board_info = {};
 	char *s;
 	if (((s = getenv("hw_id")) != NULL) && (*s != '\0')) {
 		uint32_t hw_id = simple_strtoul(s, NULL, 16);
 		board_info.revision = hw_id;
 	} else {
 		printf("Failed to retrieve Board Revision\n");
 	}

 	return add_zbi_item_or_log(zbi, capacity, ZBI_TYPE_DRV_BOARD_INFO, 0,
 				   &board_info, sizeof(board_info),
 				   "Failed to add ZBI entry for board info\n");
 }

 static void *mandatory_memset(void *dst, int c, size_t n)
 {
 	volatile unsigned char *out = dst;
 	size_t i = 0;

 	for (i = 0; i < n; ++i) {
 		out[i] = (unsigned char)c;
 	}
 	return dst;
 }

 // Define a cpu topology for the system that captures how all of the cores are
 // connected and grouped. Since this is a GICv2 system we include the ID for the
 // cores, especially since it is a tricky one with a gap between the little and
 // big clusters.
 static zbi_result_t add_cpu_topology(zbi_header_t *zbi, size_t capacity)
 {
 	int index = 0;
 	int logical_processor = 0;
 	int big_cluster = 0, little_cluster = 0;
 	zbi_topology_node_t nodes[8];
 	little_cluster = index++;
 	nodes[little_cluster] =
 		(zbi_topology_node_t){ .parent_index = ZBI_TOPOLOGY_NO_PARENT,
 				       .entity = {
 					       .discriminant =
 						       ZBI_TOPOLOGY_ENTITY_CLUSTER,
 					       .cluster = {
 						       .performance_class =
 							       0, // low performance cluster
 					       } } };
 	nodes[index++] =
 		(zbi_topology_node_t){ .parent_index = little_cluster,
 				       .entity = {
 					       .discriminant =
 						       ZBI_TOPOLOGY_ENTITY_PROCESSOR,
 					       .processor = {
 						       .logical_ids = { logical_processor++ },
 						       .logical_id_count = 1,
 						       .flags =
 							       ZBI_TOPOLOGY_PROCESSOR_FLAGS_PRIMARY,
 						       .architecture_info = {
 							       .discriminant =
 								       ZBI_TOPOLOGY_ARCHITECTURE_INFO_ARM64,
 							       .arm64 = {
 								       .cluster_1_id =
 									       0,
 								       .cpu_id =
 									       0,
 								       .gic_id =
 									       0,
 							       } } } } };
 	nodes[index++] =
 		(zbi_topology_node_t){ .parent_index = little_cluster,
 				       .entity = {
 					       .discriminant =
 						       ZBI_TOPOLOGY_ENTITY_PROCESSOR,
 					       .processor = {
 						       .logical_ids = { logical_processor++ },
 						       .logical_id_count = 1,
 						       .flags = 0,
 						       .architecture_info = {
 							       .discriminant =
 								       ZBI_TOPOLOGY_ARCHITECTURE_INFO_ARM64,
 							       .arm64 = {
 								       .cluster_1_id =
 									       0,
 								       .cpu_id =
 									       1,
 								       .gic_id =
 									       1,
 							       } } } } };
 	big_cluster = index++;
 	nodes[big_cluster] =
 		(zbi_topology_node_t){ .parent_index = ZBI_TOPOLOGY_NO_PARENT,
 				       .entity = {
 					       .discriminant =
 						       ZBI_TOPOLOGY_ENTITY_CLUSTER,
 					       .cluster = {
 						       .performance_class =
 							       1, // high performance cluster
 					       } } };
 	nodes[index++] =
 		(zbi_topology_node_t){ .parent_index = big_cluster,
 				       .entity = {
 					       .discriminant =
 						       ZBI_TOPOLOGY_ENTITY_PROCESSOR,
 					       .processor = {
 						       .logical_ids = { logical_processor++ },
 						       .logical_id_count = 1,
 						       .flags = 0,
 						       .architecture_info = {
 							       .discriminant =
 								       ZBI_TOPOLOGY_ARCHITECTURE_INFO_ARM64,
 							       .arm64 = {
 								       .cluster_1_id =
 									       1,
 								       .cpu_id =
 									       0,
 								       .gic_id =
 									       4,
 							       } } } } };
 	nodes[index++] =
 		(zbi_topology_node_t){ .parent_index = big_cluster,
 				       .entity = {
 					       .discriminant =
 						       ZBI_TOPOLOGY_ENTITY_PROCESSOR,
 					       .processor = {
 						       .logical_ids = { logical_processor++ },
 						       .logical_id_count = 1,
 						       .flags = 0,
 						       .architecture_info = {
 							       .discriminant =
 								       ZBI_TOPOLOGY_ARCHITECTURE_INFO_ARM64,
 							       .arm64 = {
 								       .cluster_1_id =
 									       1,
 								       .cpu_id =
 									       1,
 								       .gic_id =
 									       5,
 							       } } } } };
 	nodes[index++] =
 		(zbi_topology_node_t){ .parent_index = big_cluster,
 				       .entity = {
 					       .discriminant =
 						       ZBI_TOPOLOGY_ENTITY_PROCESSOR,
 					       .processor = {
 						       .logical_ids = { logical_processor++ },
 						       .logical_id_count = 1,
 						       .flags = 0,
 						       .architecture_info = {
 							       .discriminant =
 								       ZBI_TOPOLOGY_ARCHITECTURE_INFO_ARM64,
 							       .arm64 = {
 								       .cluster_1_id =
 									       1,
 								       .cpu_id =
 									       2,
 								       .gic_id =
 									       6,
 							       } } } } };
 	nodes[index++] =
 		(zbi_topology_node_t){ .parent_index = big_cluster,
 				       .entity = {
 					       .discriminant =
 						       ZBI_TOPOLOGY_ENTITY_PROCESSOR,
 					       .processor = {
 						       .logical_ids = { logical_processor++ },
 						       .logical_id_count = 1,
 						       .flags = 0,
 						       .architecture_info = {
 							       .discriminant =
 								       ZBI_TOPOLOGY_ARCHITECTURE_INFO_ARM64,
 							       .arm64 = {
 								       .cluster_1_id =
 									       1,
 								       .cpu_id =
 									       3,
 								       .gic_id =
 									       7,
 							       } } } } };

 	return add_zbi_item_or_log(
 		zbi, capacity, ZBI_TYPE_CPU_TOPOLOGY,
 		sizeof(zbi_topology_node_t), &nodes,
 		sizeof(zbi_topology_node_t) * index,
 		"Failed to add ZBI entry for CPU topology\n");
 }

 static int hex_digit(char ch)
 {
 	if (ch >= '0' && ch <= '9') {
 		return ch - '0';
 	} else if (ch >= 'a' && ch <= 'f') {
 		return ch - 'a' + 10;
 	} else if (ch >= 'A' && ch <= 'F') {
 		return ch - 'A' + 10;
 	} else {
 		return -1;
 	}
 }

 static zbi_result_t add_eth_mac_address(zbi_header_t *zbi, size_t capacity)
 {
 	char *str = getenv("eth_mac");
 	uint8_t addr[6];

 	// this would be easier with sscanf
 	int i;
 	for (i = 0; i < 6; i++) {
 		unsigned left, right;
 		if (str[0] && str[1] && (left = hex_digit(*str++)) >= 0 &&
 		    (right = hex_digit(*str++)) >= 0) {
 			addr[i] = (left << 4) | right;
 		} else {
 			goto failed;
 		}
 		if (i < 5 && *str++ != ':') {
 			goto failed;
 		}
 	}

 	return add_zbi_item_or_log(zbi, capacity, ZBI_TYPE_DRV_MAC_ADDRESS, 0,
 				   addr, sizeof(addr),
 				   "Failed to add ZBI entry for MAC address\n");

 failed:
 	printf("MAC address parsing failed for \"%s\"\n", getenv("eth_mac"));
 	return ZBI_RESULT_ERROR;
 }

 static zbi_result_t add_device_tree_from_fdt(zbi_header_t *zbi, size_t capacity)
 {
 	const void *fdt = gd->fdt_blob;
 	if (!fdt) {
 		printf("No FDT found in global data\n");
 		return ZBI_RESULT_ERROR;
 	}

 	int res = fdt_check_header(fdt);
 	if (res != 0) {
 		printf("FDT check failed: %i\n", res);
 		return ZBI_RESULT_ERROR;
 	}

 	return add_zbi_item_or_log(zbi, capacity, ZBI_TYPE_DEVICETREE, 0, fdt,
 				   fdt_totalsize(fdt),
 				   "Failed to add ZBI entry for device tree\n");
 }

 static zbi_result_t add_device_tree_from_mmc(zbi_header_t *zbi, size_t capacity)
 {
 	void *dtb_blob = NULL;
 	int rc;
 	zbi_result_t zbi_res;
 	uint32_t length;

 	struct virtual_partition *vpart =
 		aml_get_virtual_partition_by_name(MMC_DTB_NAME);
 	if (!vpart) {
 		printf("DTB partition not found\n");
 		return ZBI_RESULT_ERROR;
 	}

 	zbi_res = zbi_get_next_entry_payload(
 		zbi, zircon_image_get_capacity(zbi), &dtb_blob, &length);
 	if (zbi_res != ZBI_RESULT_OK || !dtb_blob || length < vpart->size) {
 		printf("Failed to get next entry payload for DTB of length %llu."
 		       "(next entry payload length = %u)\n",
 		       vpart->size, length);
 		return ZBI_RESULT_ERROR;
 	}

 	rc = dtb_read(dtb_blob);
 	if (rc != 0) {
 		printf("Failed to read DTB partition: %i\n", rc);
 		return ZBI_RESULT_ERROR;
 	}

 	rc = fdt_check_header(dtb_blob);
 	if (rc != 0) {
 		printf("FDT check failed: %i\n", rc);
 		return ZBI_RESULT_ERROR;
 	}

 	printf("DTB partition found (size:%llu), adding FDT (size:%u) to ZBI\n",
 	       vpart->size, fdt_totalsize(dtb_blob));

 	zbi_res = zbi_create_entry(zbi, zircon_image_get_capacity(zbi),
 				   ZBI_TYPE_DEVICETREE, 0, ZBI_FLAGS_VERSION,
 				   fdt_totalsize(dtb_blob), NULL);
 	if (zbi_res != ZBI_RESULT_OK) {
 		printf("Failed to create entry for DTB %llu\n", vpart->size);
 	}

 	return zbi_res;
 }

 static zbi_result_t add_device_tree(zbi_header_t *zbi, size_t capacity)
 {
 	zbi_result_t res = add_device_tree_from_fdt(zbi, capacity);
 	if (res != ZBI_RESULT_OK) {
 		res = add_device_tree_from_mmc(zbi, capacity);
 	}
 	return res;
 }

 // fills an 8 char buffer with the lowercase hex representation of the given
 // value.
 // WARNING this does not add a '\0' to the end of the buffer.
 static inline void uint32_to_hex(uint32_t val, char buf[static 8])
 {
 	static const char hex[] = "0123456789abcdef";
 	int i = 0;

 	for (i = 7; i >= 0; i--) {
 		buf[i] = hex[val & 0xF];
 		val >>= 4;
 	}
 }

 // Reads a value from the userspace hardware random number generator.
 // NOTE that there is no guarantee of the quality of this rng.
 static inline uint32_t read_hw_rng(void)
 {
 	return readl(RNG_USR_DATA);
 }

 static zbi_result_t add_cmdline_has_lcd(zbi_header_t *zbi, size_t capacity)
 {
 	static const char zircon_vim3_has_lcd_arg[] = "driver.vim3.has_lcd=";
 	ulong lcd_exist =
 		getenv_ulong("lcd_exist", /*base=*/10, /*default_val=*/0);

 	char vim3_has_lcd_cmdline[64];
 	snprintf(vim3_has_lcd_cmdline, sizeof(vim3_has_lcd_cmdline), "%s%s",
 		 zircon_vim3_has_lcd_arg, lcd_exist ? "true" : "false");

 	return add_zbi_item_or_log(zbi, capacity, ZBI_TYPE_CMDLINE, 0,
 				   vim3_has_lcd_cmdline,
 				   strlen(vim3_has_lcd_cmdline),
 				   "Failed to add ZBI entry for cmdline\n");
 }

 static zbi_result_t add_cmdline_entropy(zbi_header_t *zbi, size_t capacity)
 {
 	strcpy(entropy_cmdline, zircon_entropy_arg);
 	char *entropy = entropy_cmdline + strlen(zircon_entropy_arg);
 	int i = 0;
 	zbi_result_t res;

 	for (i = 0; i < CMDLINE_ENTROPY_BITS; i += 32) {
 		uint32_to_hex(read_hw_rng(), entropy);
 		entropy += 8;
 	}
 	*entropy = '\0';

 	res = add_zbi_item_or_log(
 		zbi, capacity, ZBI_TYPE_CMDLINE, 0, entropy_cmdline,
 		sizeof(entropy_cmdline),
 		"Failed to add ZBI entry for cmdline entropy\n");

 	mandatory_memset(entropy_cmdline, '\0', sizeof(entropy_cmdline));
 	return res;
 }

 int zircon_preboot(zbi_header_t *zbi, size_t capacity)
 {
 #if 0 //Deprecated cpu topology descripiton
 	add_zbi_item_or_log(zbi, capacity, ZBI_TYPE_CPU_CONFIG,  0, &cpu_config,
 						sizeof(zbi_cpu_config_t) +
 						sizeof(zbi_cpu_cluster_t) * cpu_config.cluster_count,
 						"Failed to add ZBI entry for CPU config\n");
     printf("Appended ZBI_TYPE_CPU_CONFIG - %x\n",zbi->length);
 #endif

 #if 0 // Old method of overriding vim3 memory suze.
     //TODO - vim3 does not define a ddr_size env variable.  Since there are two
     // variants of vim3, need to figure out how to figure this out from u-boot
     const char* ddr_size = getenv("ddr_size");
     if (!strcmp(ddr_size, "3")) {
         mem_config[0].length = 0xc0000000;
     }
 #endif

 	// Compute the available memory.
 	uint64_t mem_bytes = CONFIG_SYS_MEM_TOP_HIDE; // Add back hidden ram.
 	for (int i = 0; i < CONFIG_NR_DRAM_BANKS; i++) {
 		printf("Dram bank %d has 0x%lx\n", i, gd->bd->bi_dram[i].size);
 		mem_bytes += gd->bd->bi_dram[i].size;
 	}
 	mem_config[0].length = mem_bytes;

 	// A little math to print the memory without (ab)using floats.
 	const uint32_t mem_mbytes = mem_bytes / (1024 * 1024);
 	const uint32_t mem_gbytes = mem_mbytes / 1024;
 	const uint32_t mem_remaining_mbytes = mem_mbytes % 1024;
 	printf("ZBI_MEM_RANGE_RAM is 0x%" PRIx64
 	       " (%d.%03d GiB) in %d bank(s)\n",
 	       mem_config[0].length, mem_gbytes,
 	       mem_remaining_mbytes * 1000 / 1024, CONFIG_NR_DRAM_BANKS);

 	// add memory configuration
 	add_zbi_item_or_log(zbi, capacity, ZBI_TYPE_MEM_CONFIG, 0, &mem_config,
 			    sizeof(mem_config),
 			    "Failed to add ZBI entry for memory config\n");

 	// Reserve crashlog save area at very end of RAM.
 	// This space is currently left untouched via CONFIG_SYS_MEM_TOP_HIDE,
 	// but we don't actually need to hide it so we reclaim some of it for
 	// NVRAM (http://b/302699144#comment4).
 	_Static_assert(NVRAM_LENGTH <= CONFIG_SYS_MEM_TOP_HIDE);
 	zbi_nvram_t nvram;
 	nvram.base = mem_config[0].length - NVRAM_LENGTH;
 	nvram.length = NVRAM_LENGTH;
 	add_zbi_item_or_log(zbi, capacity, ZBI_TYPE_NVRAM, 0, &nvram,
 			    sizeof(nvram),
 			    "Failed to add ZBI entry for NVRAM\n");

 	// add kernel drivers
 	add_zbi_item_or_log(
 		zbi, capacity, ZBI_TYPE_KERNEL_DRIVER,
 		ZBI_KERNEL_DRIVER_AMLOGIC_UART, &uart_driver,
 		sizeof(uart_driver),
 		"Failed to add ZBI entry for kernel driver AMLOGIC_UART\n");
 	add_zbi_item_or_log(
 		zbi, capacity, ZBI_TYPE_KERNEL_DRIVER,
 		ZBI_KERNEL_DRIVER_ARM_GIC_V2, &gicv2_driver,
 		sizeof(gicv2_driver),
 		"Failed to add ZBI entry for kernel driver ARM_GIC_V2\n");
 	add_zbi_item_or_log(
 		zbi, capacity, ZBI_TYPE_KERNEL_DRIVER,
 		ZBI_KERNEL_DRIVER_ARM_PSCI, &psci_driver, sizeof(psci_driver),
 		"Failed to add ZBI entry for kernel driver ARM_PSCI\n");
 	add_zbi_item_or_log(
 		zbi, capacity, ZBI_TYPE_KERNEL_DRIVER,
 		ZBI_KERNEL_DRIVER_ARM_GENERIC_TIMER, &timer_driver,
 		sizeof(timer_driver),
 		"Failed to add ZBI entry for kernel driver ARM_GENERIC_TIMER\n");
 	// add_zbi_item_or_log(zbi, capacity, ZBI_TYPE_KERNEL_DRIVER, KDRV_AMLOGIC_HDCP, &hdcp_driver,
 	//					   sizeof(hdcp_driver),
 	//					   "Failed to add ZBI entry for kernel driver AMLOGIC_HDCP\n");

 	add_zbi_item_or_log(
 		zbi, capacity, ZBI_TYPE_CMDLINE, 0, BOOTLOADER_VERSION,
 		strlen(BOOTLOADER_VERSION) + 1,
 		"Failed to add ZBI entry for cmdline bootloader version\n");

 	// add platform ID
 	add_zbi_item_or_log(zbi, capacity, ZBI_TYPE_PLATFORM_ID, 0,
 			    &platform_id, sizeof(platform_id),
 			    "Failed to add ZBI entry for platform ID\n");

 	add_serial_number(zbi, capacity);
 	add_board_info(zbi, capacity);
 	add_cmdline_has_lcd(zbi, capacity);
 	add_cmdline_entropy(zbi, capacity);
 	add_cpu_topology(zbi, capacity);
 	add_eth_mac_address(zbi, capacity);
 	add_device_tree(zbi, capacity);
 	return 0;
 }
	/*
	* Copyright (c) 2018 The Fuchsia Authors
	*
	* SPDX-License-Identifier: BSD-3-Clause
	*/

	#include <aml_i2c.h>
	#include <asm/arch/secure_apb.h>
	#include <asm/global_data.h>
	#include <common.h>
	#include <emmc_partitions.h>
	#include <g_dnl.h>
	#include <inttypes.h>
	#include <lib/zbi/zbi.h>
	#include <lib/zbi-format/board.h>
	#include <lib/zbi-format/cpu.h>
	#include <lib/zbi-format/memory.h>
	#include <libfdt.h>
	#include <part.h>
	#include <zircon.h>

	#define PDEV_VID_KHADAS 4
	#define PDEV_PID_VIM2 2
	#define PDEV_PID_VIM3 3

	#define NVRAM_LENGTH (16 * 1024)

	#define CMDLINE_ENTROPY_SIZE 1024
	#define CMDLINE_ENTROPY_BITS 256 // random bits to pass to zircon.

	#define ENTROPY_BITS_PER_CHAR 4

	DECLARE_GLOBAL_DATA_PTR;

	static char entropy_cmdline[CMDLINE_ENTROPY_SIZE] = { 0 };
	static const char zircon_entropy_arg[] = "kernel.entropy-mixin=";

	#define static_assert _Static_assert
	static_assert(CMDLINE_ENTROPY_BITS % 32 == 0,
	"Requested entropy must be a multiple of 32");

	static_assert((CMDLINE_ENTROPY_BITS / ENTROPY_BITS_PER_CHAR) +
	sizeof(zircon_entropy_arg) <
	CMDLINE_ENTROPY_SIZE,
	"Requested entropy doesn't fit in cmdline.");

	static const char BOOTLOADER_VERSION[] = "zircon-bootloader=0.12";

	static zbi_mem_range_t mem_config[] = {
	{
	.type = ZBI_MEM_TYPE_RAM,
	.length = 0x80000000,
	},
	{
	.type = ZBI_MEM_TYPE_PERIPHERAL,
	.paddr = 0xfe000000,
	.length = 0x02000000,
	},
	{
	.type = ZBI_MEM_TYPE_RESERVED,
	.paddr = 0x07400000,
	.length = 0x00100000,
	},
	{
	.type = ZBI_MEM_TYPE_RESERVED,
	.paddr = 0x05000000,
	.length = 0x02300000,
	},
	};

	static const zbi_dcfg_simple_t uart_driver = {
	.mmio_phys = 0xff803000,
	.irq = 225,
	};

	static const zbi_dcfg_arm_gic_v2_driver_t gicv2_driver = {
	.mmio_phys = 0xffc00000,
	.gicd_offset = 0x1000,
	.gicc_offset = 0x2000,
	.gich_offset = 0x4000,
	.gicv_offset = 0x6000,
	.ipi_base = 5,
	};

	static const zbi_dcfg_arm_psci_driver_t psci_driver = {
	.use_hvc = false,
	.reboot_args = { 1, 0, 0 },
	.reboot_bootloader_args = { 4, 0, 0 },
	.reboot_recovery_args = { 2, 0, 0 },
	};

	static const zbi_dcfg_arm_generic_timer_driver_t timer_driver = {
	.irq_phys = 30,
	};

	static const zbi_platform_id_t platform_id = {
	.vid = PDEV_VID_KHADAS,
	.pid = PDEV_PID_VIM3,
	.board_name = "vim3",
	};

	enum {
	PART_BOOTLOADER,
	PART_ZIRCON_A,
	PART_ZIRCON_B,
	PART_ZIRCON_R,
	PART_SYS_CONFIG,
	PART_FACTORY_CONFIG,
	PART_FVM,
	PART_COUNT,
	};

	extern int dtb_read(void *addr);

	zbi_result_t add_zbi_item_or_log(void *zbi, size_t capacity, uint32_t type,
	uint32_t extra, const void *payload,
	size_t payload_length, const char *format, ...)
	{
	zbi_result_t result = zbi_create_entry_with_payload(
	zbi, capacity, type, extra, 0, payload, payload_length);
	if (result != ZBI_RESULT_OK) {
	va_list args;
	va_start(args, format);
	vprintf(format, args);
	va_end(args);
	}
	return result;
	}

	static zbi_result_t add_serial_number(zbi_header_t *zbi, size_t capacity)
	{
	// Serial number from secure storage takes priority, if it exists.
	// Otherwise use the "serial" env var.
	// TODO: we may want to unify this logic with the fastboot logic to
	// make sure they stay in sync.
	const char *s = get_usid_string();
	if (!s) {
	s = getenv("serial");
	}
	if (!s \|\| (*s == '\0')) {
	printf("Failed to retrieve serial number\n");
	return ZBI_RESULT_ERROR;
	}

	return add_zbi_item_or_log(
	zbi, capacity, ZBI_TYPE_SERIAL_NUMBER, 0, s, strlen(s),
	"Failed to add ZBI entry for serial number\n");
	}

	static zbi_result_t add_board_info(zbi_header_t *zbi, size_t capacity)
	{
	zbi_board_info_t board_info = {};
	char *s;
	if (((s = getenv("hw_id")) != NULL) && (*s != '\0')) {
	uint32_t hw_id = simple_strtoul(s, NULL, 16);
	board_info.revision = hw_id;
	} else {
	printf("Failed to retrieve Board Revision\n");
	}

	return add_zbi_item_or_log(zbi, capacity, ZBI_TYPE_DRV_BOARD_INFO, 0,
	&board_info, sizeof(board_info),
	"Failed to add ZBI entry for board info\n");
	}

	static void mandatory_memset(void dst, int c, size_t n)
	{
	volatile unsigned char *out = dst;
	size_t i = 0;

	for (i = 0; i < n; ++i) {
	out[i] = (unsigned char)c;
	}
	return dst;
	}

	// Define a cpu topology for the system that captures how all of the cores are
	// connected and grouped. Since this is a GICv2 system we include the ID for the
	// cores, especially since it is a tricky one with a gap between the little and
	// big clusters.
	static zbi_result_t add_cpu_topology(zbi_header_t *zbi, size_t capacity)
	{
	int index = 0;
	int logical_processor = 0;
	int big_cluster = 0, little_cluster = 0;
	zbi_topology_node_t nodes[8];
	little_cluster = index++;
	nodes[little_cluster] =
	(zbi_topology_node_t){ .parent_index = ZBI_TOPOLOGY_NO_PARENT,
	.entity = {
	.discriminant =
	ZBI_TOPOLOGY_ENTITY_CLUSTER,
	.cluster = {
	.performance_class =
	0, // low performance cluster
	} } };
	nodes[index++] =
	(zbi_topology_node_t){ .parent_index = little_cluster,
	.entity = {
	.discriminant =
	ZBI_TOPOLOGY_ENTITY_PROCESSOR,
	.processor = {
	.logical_ids = { logical_processor++ },
	.logical_id_count = 1,
	.flags =
	ZBI_TOPOLOGY_PROCESSOR_FLAGS_PRIMARY,
	.architecture_info = {
	.discriminant =
	ZBI_TOPOLOGY_ARCHITECTURE_INFO_ARM64,
	.arm64 = {
	.cluster_1_id =
	0,
	.cpu_id =
	0,
	.gic_id =
	0,
	} } } } };
	nodes[index++] =
	(zbi_topology_node_t){ .parent_index = little_cluster,
	.entity = {
	.discriminant =
	ZBI_TOPOLOGY_ENTITY_PROCESSOR,
	.processor = {
	.logical_ids = { logical_processor++ },
	.logical_id_count = 1,
	.flags = 0,
	.architecture_info = {
	.discriminant =
	ZBI_TOPOLOGY_ARCHITECTURE_INFO_ARM64,
	.arm64 = {
	.cluster_1_id =
	0,
	.cpu_id =
	1,
	.gic_id =
	1,
	} } } } };
	big_cluster = index++;
	nodes[big_cluster] =
	(zbi_topology_node_t){ .parent_index = ZBI_TOPOLOGY_NO_PARENT,
	.entity = {
	.discriminant =
	ZBI_TOPOLOGY_ENTITY_CLUSTER,
	.cluster = {
	.performance_class =
	1, // high performance cluster
	} } };
	nodes[index++] =
	(zbi_topology_node_t){ .parent_index = big_cluster,
	.entity = {
	.discriminant =
	ZBI_TOPOLOGY_ENTITY_PROCESSOR,
	.processor = {
	.logical_ids = { logical_processor++ },
	.logical_id_count = 1,
	.flags = 0,
	.architecture_info = {
	.discriminant =
	ZBI_TOPOLOGY_ARCHITECTURE_INFO_ARM64,
	.arm64 = {
	.cluster_1_id =
	1,
	.cpu_id =
	0,
	.gic_id =
	4,
	} } } } };
	nodes[index++] =
	(zbi_topology_node_t){ .parent_index = big_cluster,
	.entity = {
	.discriminant =
	ZBI_TOPOLOGY_ENTITY_PROCESSOR,
	.processor = {
	.logical_ids = { logical_processor++ },
	.logical_id_count = 1,
	.flags = 0,
	.architecture_info = {
	.discriminant =
	ZBI_TOPOLOGY_ARCHITECTURE_INFO_ARM64,
	.arm64 = {
	.cluster_1_id =
	1,
	.cpu_id =
	1,
	.gic_id =
	5,
	} } } } };
	nodes[index++] =
	(zbi_topology_node_t){ .parent_index = big_cluster,
	.entity = {
	.discriminant =
	ZBI_TOPOLOGY_ENTITY_PROCESSOR,
	.processor = {
	.logical_ids = { logical_processor++ },
	.logical_id_count = 1,
	.flags = 0,
	.architecture_info = {
	.discriminant =
	ZBI_TOPOLOGY_ARCHITECTURE_INFO_ARM64,
	.arm64 = {
	.cluster_1_id =
	1,
	.cpu_id =
	2,
	.gic_id =
	6,
	} } } } };
	nodes[index++] =
	(zbi_topology_node_t){ .parent_index = big_cluster,
	.entity = {
	.discriminant =
	ZBI_TOPOLOGY_ENTITY_PROCESSOR,
	.processor = {
	.logical_ids = { logical_processor++ },
	.logical_id_count = 1,
	.flags = 0,
	.architecture_info = {
	.discriminant =
	ZBI_TOPOLOGY_ARCHITECTURE_INFO_ARM64,
	.arm64 = {
	.cluster_1_id =
	1,
	.cpu_id =
	3,
	.gic_id =
	7,
	} } } } };

	return add_zbi_item_or_log(
	zbi, capacity, ZBI_TYPE_CPU_TOPOLOGY,
	sizeof(zbi_topology_node_t), &nodes,
	sizeof(zbi_topology_node_t) * index,
	"Failed to add ZBI entry for CPU topology\n");
	}

	static int hex_digit(char ch)
	{
	if (ch >= '0' && ch <= '9') {
	return ch - '0';
	} else if (ch >= 'a' && ch <= 'f') {
	return ch - 'a' + 10;
	} else if (ch >= 'A' && ch <= 'F') {
	return ch - 'A' + 10;
	} else {
	return -1;
	}
	}

	static zbi_result_t add_eth_mac_address(zbi_header_t *zbi, size_t capacity)
	{
	char *str = getenv("eth_mac");
	uint8_t addr[6];

	// this would be easier with sscanf
	int i;
	for (i = 0; i < 6; i++) {
	unsigned left, right;
	if (str[0] && str[1] && (left = hex_digit(*str++)) >= 0 &&
	(right = hex_digit(*str++)) >= 0) {
	addr[i] = (left << 4) \| right;
	} else {
	goto failed;
	}
	if (i < 5 && *str++ != ':') {
	goto failed;
	}
	}

	return add_zbi_item_or_log(zbi, capacity, ZBI_TYPE_DRV_MAC_ADDRESS, 0,
	addr, sizeof(addr),
	"Failed to add ZBI entry for MAC address\n");

	failed:
	printf("MAC address parsing failed for \"%s\"\n", getenv("eth_mac"));
	return ZBI_RESULT_ERROR;
	}

	static zbi_result_t add_device_tree_from_fdt(zbi_header_t *zbi, size_t capacity)
	{
	const void *fdt = gd->fdt_blob;
	if (!fdt) {
	printf("No FDT found in global data\n");
	return ZBI_RESULT_ERROR;
	}

	int res = fdt_check_header(fdt);
	if (res != 0) {
	printf("FDT check failed: %i\n", res);
	return ZBI_RESULT_ERROR;
	}

	return add_zbi_item_or_log(zbi, capacity, ZBI_TYPE_DEVICETREE, 0, fdt,
	fdt_totalsize(fdt),
	"Failed to add ZBI entry for device tree\n");
	}

	static zbi_result_t add_device_tree_from_mmc(zbi_header_t *zbi, size_t capacity)
	{
	void *dtb_blob = NULL;
	int rc;
	zbi_result_t zbi_res;
	uint32_t length;

	struct virtual_partition *vpart =
	aml_get_virtual_partition_by_name(MMC_DTB_NAME);
	if (!vpart) {
	printf("DTB partition not found\n");
	return ZBI_RESULT_ERROR;
	}

	zbi_res = zbi_get_next_entry_payload(
	zbi, zircon_image_get_capacity(zbi), &dtb_blob, &length);
	if (zbi_res != ZBI_RESULT_OK \|\| !dtb_blob \|\| length < vpart->size) {
	printf("Failed to get next entry payload for DTB of length %llu."
	"(next entry payload length = %u)\n",
	vpart->size, length);
	return ZBI_RESULT_ERROR;
	}

	rc = dtb_read(dtb_blob);
	if (rc != 0) {
	printf("Failed to read DTB partition: %i\n", rc);
	return ZBI_RESULT_ERROR;
	}

	rc = fdt_check_header(dtb_blob);
	if (rc != 0) {
	printf("FDT check failed: %i\n", rc);
	return ZBI_RESULT_ERROR;
	}

	printf("DTB partition found (size:%llu), adding FDT (size:%u) to ZBI\n",
	vpart->size, fdt_totalsize(dtb_blob));

	zbi_res = zbi_create_entry(zbi, zircon_image_get_capacity(zbi),
	ZBI_TYPE_DEVICETREE, 0, ZBI_FLAGS_VERSION,
	fdt_totalsize(dtb_blob), NULL);
	if (zbi_res != ZBI_RESULT_OK) {
	printf("Failed to create entry for DTB %llu\n", vpart->size);
	}

	return zbi_res;
	}

	static zbi_result_t add_device_tree(zbi_header_t *zbi, size_t capacity)
	{
	zbi_result_t res = add_device_tree_from_fdt(zbi, capacity);
	if (res != ZBI_RESULT_OK) {
	res = add_device_tree_from_mmc(zbi, capacity);
	}
	return res;
	}

	// fills an 8 char buffer with the lowercase hex representation of the given
	// value.
	// WARNING this does not add a '\0' to the end of the buffer.
	static inline void uint32_to_hex(uint32_t val, char buf[static 8])
	{
	static const char hex[] = "0123456789abcdef";
	int i = 0;

	for (i = 7; i >= 0; i--) {
	buf[i] = hex[val & 0xF];
	val >>= 4;
	}
	}

	// Reads a value from the userspace hardware random number generator.
	// NOTE that there is no guarantee of the quality of this rng.
	static inline uint32_t read_hw_rng(void)
	{
	return readl(RNG_USR_DATA);
	}

	static zbi_result_t add_cmdline_has_lcd(zbi_header_t *zbi, size_t capacity)
	{
	static const char zircon_vim3_has_lcd_arg[] = "driver.vim3.has_lcd=";
	ulong lcd_exist =
	getenv_ulong("lcd_exist", /base=/10, /default_val=/0);

	char vim3_has_lcd_cmdline[64];
	snprintf(vim3_has_lcd_cmdline, sizeof(vim3_has_lcd_cmdline), "%s%s",
	zircon_vim3_has_lcd_arg, lcd_exist ? "true" : "false");

	return add_zbi_item_or_log(zbi, capacity, ZBI_TYPE_CMDLINE, 0,
	vim3_has_lcd_cmdline,
	strlen(vim3_has_lcd_cmdline),
	"Failed to add ZBI entry for cmdline\n");
	}

	static zbi_result_t add_cmdline_entropy(zbi_header_t *zbi, size_t capacity)
	{
	strcpy(entropy_cmdline, zircon_entropy_arg);
	char *entropy = entropy_cmdline + strlen(zircon_entropy_arg);
	int i = 0;
	zbi_result_t res;

	for (i = 0; i < CMDLINE_ENTROPY_BITS; i += 32) {
	uint32_to_hex(read_hw_rng(), entropy);
	entropy += 8;
	}
	*entropy = '\0';

	res = add_zbi_item_or_log(
	zbi, capacity, ZBI_TYPE_CMDLINE, 0, entropy_cmdline,
	sizeof(entropy_cmdline),
	"Failed to add ZBI entry for cmdline entropy\n");

	mandatory_memset(entropy_cmdline, '\0', sizeof(entropy_cmdline));
	return res;
	}

	int zircon_preboot(zbi_header_t *zbi, size_t capacity)
	{
	#if 0 //Deprecated cpu topology descripiton
	add_zbi_item_or_log(zbi, capacity, ZBI_TYPE_CPU_CONFIG, 0, &cpu_config,
	sizeof(zbi_cpu_config_t) +
	sizeof(zbi_cpu_cluster_t) * cpu_config.cluster_count,
	"Failed to add ZBI entry for CPU config\n");
	printf("Appended ZBI_TYPE_CPU_CONFIG - %x\n",zbi->length);
	#endif

	#if 0 // Old method of overriding vim3 memory suze.
	//TODO - vim3 does not define a ddr_size env variable. Since there are two
	// variants of vim3, need to figure out how to figure this out from u-boot
	const char* ddr_size = getenv("ddr_size");
	if (!strcmp(ddr_size, "3")) {
	mem_config[0].length = 0xc0000000;
	}
	#endif

	// Compute the available memory.
	uint64_t mem_bytes = CONFIG_SYS_MEM_TOP_HIDE; // Add back hidden ram.
	for (int i = 0; i < CONFIG_NR_DRAM_BANKS; i++) {
	printf("Dram bank %d has 0x%lx\n", i, gd->bd->bi_dram[i].size);
	mem_bytes += gd->bd->bi_dram[i].size;
	}
	mem_config[0].length = mem_bytes;

	// A little math to print the memory without (ab)using floats.
	const uint32_t mem_mbytes = mem_bytes / (1024 * 1024);
	const uint32_t mem_gbytes = mem_mbytes / 1024;
	const uint32_t mem_remaining_mbytes = mem_mbytes % 1024;
	printf("ZBI_MEM_RANGE_RAM is 0x%" PRIx64
	" (%d.%03d GiB) in %d bank(s)\n",
	mem_config[0].length, mem_gbytes,
	mem_remaining_mbytes * 1000 / 1024, CONFIG_NR_DRAM_BANKS);

	// add memory configuration
	add_zbi_item_or_log(zbi, capacity, ZBI_TYPE_MEM_CONFIG, 0, &mem_config,
	sizeof(mem_config),
	"Failed to add ZBI entry for memory config\n");

	// Reserve crashlog save area at very end of RAM.
	// This space is currently left untouched via CONFIG_SYS_MEM_TOP_HIDE,
	// but we don't actually need to hide it so we reclaim some of it for
	// NVRAM (http://b/302699144#comment4).
	_Static_assert(NVRAM_LENGTH <= CONFIG_SYS_MEM_TOP_HIDE);
	zbi_nvram_t nvram;
	nvram.base = mem_config[0].length - NVRAM_LENGTH;
	nvram.length = NVRAM_LENGTH;
	add_zbi_item_or_log(zbi, capacity, ZBI_TYPE_NVRAM, 0, &nvram,
	sizeof(nvram),
	"Failed to add ZBI entry for NVRAM\n");

	// add kernel drivers
	add_zbi_item_or_log(
	zbi, capacity, ZBI_TYPE_KERNEL_DRIVER,
	ZBI_KERNEL_DRIVER_AMLOGIC_UART, &uart_driver,
	sizeof(uart_driver),
	"Failed to add ZBI entry for kernel driver AMLOGIC_UART\n");
	add_zbi_item_or_log(
	zbi, capacity, ZBI_TYPE_KERNEL_DRIVER,
	ZBI_KERNEL_DRIVER_ARM_GIC_V2, &gicv2_driver,
	sizeof(gicv2_driver),
	"Failed to add ZBI entry for kernel driver ARM_GIC_V2\n");
	add_zbi_item_or_log(
	zbi, capacity, ZBI_TYPE_KERNEL_DRIVER,
	ZBI_KERNEL_DRIVER_ARM_PSCI, &psci_driver, sizeof(psci_driver),
	"Failed to add ZBI entry for kernel driver ARM_PSCI\n");
	add_zbi_item_or_log(
	zbi, capacity, ZBI_TYPE_KERNEL_DRIVER,
	ZBI_KERNEL_DRIVER_ARM_GENERIC_TIMER, &timer_driver,
	sizeof(timer_driver),
	"Failed to add ZBI entry for kernel driver ARM_GENERIC_TIMER\n");
	// add_zbi_item_or_log(zbi, capacity, ZBI_TYPE_KERNEL_DRIVER, KDRV_AMLOGIC_HDCP, &hdcp_driver,
	// sizeof(hdcp_driver),
	// "Failed to add ZBI entry for kernel driver AMLOGIC_HDCP\n");

	add_zbi_item_or_log(
	zbi, capacity, ZBI_TYPE_CMDLINE, 0, BOOTLOADER_VERSION,
	strlen(BOOTLOADER_VERSION) + 1,
	"Failed to add ZBI entry for cmdline bootloader version\n");

	// add platform ID
	add_zbi_item_or_log(zbi, capacity, ZBI_TYPE_PLATFORM_ID, 0,
	&platform_id, sizeof(platform_id),
	"Failed to add ZBI entry for platform ID\n");

	add_serial_number(zbi, capacity);
	add_board_info(zbi, capacity);
	add_cmdline_has_lcd(zbi, capacity);
	add_cmdline_entropy(zbi, capacity);
	add_cpu_topology(zbi, capacity);
	add_eth_mac_address(zbi, capacity);
	add_device_tree(zbi, capacity);
	return 0;
	}