| // Copyright 2018 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <common.h> |
| #include <part.h> |
| #include <zircon/zircon.h> |
| |
| #define PDEV_VID_GOOGLE 3 |
| #define PDEV_PID_MADRONE 4 |
| |
| #define NVRAM_LENGTH (1024 * 1024) |
| |
| static const zbi_cpu_config_t cpu_config = { |
| .cluster_count = 1, |
| .clusters = { |
| { |
| .cpu_count = 4, |
| }, |
| }, |
| }; |
| |
| static const zbi_mem_range_t mem_config[] = { |
| { |
| .type = ZBI_MEM_RANGE_RAM, |
| .paddr = 0x40000000, |
| .length = 0xc0000000, // 3GB |
| }, |
| { |
| .type = ZBI_MEM_RANGE_PERIPHERAL, |
| .paddr = 0, |
| .length = 0x40000000, |
| }, |
| }; |
| |
| static const dcfg_simple_t uart_driver = { |
| .mmio_phys = 0x30860000, |
| .irq = 58, |
| }; |
| |
| static const dcfg_arm_gicv3_driver_t gicv3_driver = { |
| .mmio_phys = 0x38800000, |
| .gicd_offset = 0x00000, |
| .gicr_offset = 0x80000, |
| .gicr_stride = 0x20000, |
| .ipi_base = 9, |
| // Used for Errata e11171 |
| .mx8_gpr_phys = 0x30340000, |
| }; |
| |
| static const dcfg_arm_psci_driver_t psci_driver = { |
| .use_hvc = false, |
| }; |
| |
| static const dcfg_arm_generic_timer_driver_t timer_driver = { |
| .irq_phys = 30, |
| .irq_virt = 27, |
| .freq_override = 8333333, |
| }; |
| |
| static const zbi_platform_id_t platform_id = { |
| .vid = PDEV_VID_GOOGLE, |
| .pid = PDEV_PID_MADRONE, |
| .board_name = "madrone", |
| }; |
| |
| enum { |
| PART_ZIRCON_A, |
| PART_ZIRCON_B, |
| PART_ZIRCON_R, |
| PART_SYS_CONFIG, |
| PART_FACTORY_CONFIG, |
| PART_FVM, |
| PART_COUNT, |
| }; |
| |
| static zbi_partition_map_t partition_map = { |
| // .block_count filled in below |
| // .block_size filled in below |
| .guid = {}, |
| .partition_count = PART_COUNT, |
| .partitions = { |
| { |
| .type_guid = GUID_ZIRCON_A_VALUE, |
| .uniq_guid = {}, |
| // .first_block filled in below |
| // .last_block filled in below |
| .flags = 0, |
| .name = "zircon-a", |
| }, |
| { |
| .type_guid = GUID_ZIRCON_B_VALUE, |
| .uniq_guid = {}, |
| // .first_block filled in below |
| // .last_block filled in below |
| .flags = 0, |
| .name = "zircon-b", |
| }, |
| { |
| .type_guid = GUID_ZIRCON_R_VALUE, |
| .uniq_guid = {}, |
| // .first_block filled in below |
| // .last_block filled in below |
| .flags = 0, |
| .name = "zircon-r", |
| }, |
| { |
| .type_guid = GUID_SYS_CONFIG_VALUE, |
| .uniq_guid = {}, |
| // .first_block filled in below |
| // .last_block filled in below |
| .flags = 0, |
| .name = "sys-config", |
| }, |
| { |
| .type_guid = GUID_FACTORY_CONFIG_VALUE, |
| .uniq_guid = {}, |
| // .first_block filled in below |
| // .last_block filled in below |
| .flags = 0, |
| .name = "factory", |
| }, |
| { |
| .type_guid = GUID_FVM_VALUE, |
| .uniq_guid = {}, |
| // .first_block filled in below |
| // .last_block filled in below |
| .flags = 0, |
| .name = "fvm", |
| }, |
| }, |
| }; |
| |
| static void add_partition_map(zbi_header_t* zbi) { |
| struct blk_desc* dev_desc; |
| disk_partition_t boot_a_info; |
| disk_partition_t boot_b_info; |
| disk_partition_t system_a_info; |
| disk_partition_t misc_info; |
| disk_partition_t factory_info; |
| disk_partition_t userdata_info; |
| |
| dev_desc = blk_get_dev("mmc", 0); |
| if (!dev_desc || dev_desc->type == DEV_TYPE_UNKNOWN) { |
| printf("could not find MMC device for partition map\n"); |
| return; |
| } |
| |
| if (part_get_info_by_name(dev_desc, "boot_a", &boot_a_info)) { |
| printf("could not find boot_a partition\n"); |
| return; |
| } |
| if (part_get_info_by_name(dev_desc, "boot_b", &boot_b_info)) { |
| printf("could not find boot_b partition\n"); |
| return; |
| } |
| if (part_get_info_by_name(dev_desc, "system_a", &system_a_info)) { |
| printf("could not find system_a partition\n"); |
| return; |
| } |
| if (part_get_info_by_name(dev_desc, "misc", &misc_info)) { |
| printf("could not find misc partition\n"); |
| return; |
| } |
| if (part_get_info_by_name(dev_desc, "factory", &factory_info)) { |
| printf("could not find factory partition\n"); |
| return; |
| } |
| if (part_get_info_by_name(dev_desc, "userdata", &userdata_info)) { |
| printf("could not find userdata partition\n"); |
| return; |
| } |
| |
| // map boot_a partition to ZIRCON_A |
| partition_map.partitions[PART_ZIRCON_A].first_block = boot_a_info.start; |
| partition_map.partitions[PART_ZIRCON_A].last_block = boot_a_info.start + boot_a_info.size - 1; |
| |
| // map boot_b partition to ZIRCON_B |
| partition_map.partitions[PART_ZIRCON_B].first_block = boot_b_info.start; |
| partition_map.partitions[PART_ZIRCON_B].last_block = boot_b_info.start + boot_b_info.size - 1; |
| |
| // map system_a partition to ZIRCON_R |
| partition_map.partitions[PART_ZIRCON_R].first_block = system_a_info.start; |
| partition_map.partitions[PART_ZIRCON_R].last_block = system_a_info.start + |
| system_a_info.size - 1; |
| |
| // map misc partition to SYS_CONFIG |
| partition_map.partitions[PART_SYS_CONFIG].first_block = misc_info.start; |
| partition_map.partitions[PART_SYS_CONFIG].last_block = misc_info.start + misc_info.size - 1; |
| |
| // map factory partition to FACTORY_CONFIG |
| partition_map.partitions[PART_FACTORY_CONFIG].first_block = factory_info.start; |
| partition_map.partitions[PART_FACTORY_CONFIG].last_block = factory_info.start + |
| factory_info.size - 1; |
| |
| // map userdata partition to FVM |
| partition_map.partitions[PART_FVM].first_block = userdata_info.start; |
| partition_map.partitions[PART_FVM].last_block = userdata_info.start + |
| userdata_info.size - 1; |
| |
| partition_map.block_count = userdata_info.start + userdata_info.size; |
| partition_map.block_size = userdata_info.blksz; |
| |
| zircon_append_boot_item(zbi, ZBI_TYPE_DRV_PARTITION_MAP, 0, &partition_map, |
| sizeof(zbi_partition_map_t) + |
| partition_map.partition_count * sizeof(zbi_partition_t)); |
| } |
| |
| #if 0 |
| 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 void add_eth_mac_address(zbi_header_t* zbi) { |
| 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; |
| } |
| } |
| |
| zircon_append_boot_item(zbi, ZBI_TYPE_DRV_MAC_ADDRESS, 0, addr, sizeof(addr)); |
| return; |
| |
| failed: |
| printf("MAC address parsing failed for \"%s\"\n", getenv("eth_mac")); |
| } |
| #endif |
| |
| int zircon_preboot(zbi_header_t* zbi) { |
| // add CPU configuration |
| zircon_append_boot_item(zbi, ZBI_TYPE_CPU_CONFIG, 0, &cpu_config, |
| sizeof(zbi_cpu_config_t) + |
| sizeof(zbi_cpu_cluster_t) * cpu_config.cluster_count); |
| |
| // allocate crashlog save area at end of RAM |
| zbi_nvram_t nvram; |
| nvram.base = mem_config[0].length - NVRAM_LENGTH; |
| nvram.length = NVRAM_LENGTH; |
| zircon_append_boot_item(zbi, ZBI_TYPE_NVRAM, 0, &nvram, sizeof(nvram)); |
| |
| // add memory configuration |
| zircon_append_boot_item(zbi, ZBI_TYPE_MEM_CONFIG, 0, &mem_config, sizeof(mem_config)); |
| |
| // add kernel drivers |
| zircon_append_boot_item(zbi, ZBI_TYPE_KERNEL_DRIVER, KDRV_NXP_IMX_UART, &uart_driver, |
| sizeof(uart_driver)); |
| zircon_append_boot_item(zbi, ZBI_TYPE_KERNEL_DRIVER, KDRV_ARM_GIC_V3, &gicv3_driver, |
| sizeof(gicv3_driver)); |
| zircon_append_boot_item(zbi, ZBI_TYPE_KERNEL_DRIVER, KDRV_ARM_PSCI, &psci_driver, |
| sizeof(psci_driver)); |
| zircon_append_boot_item(zbi, ZBI_TYPE_KERNEL_DRIVER, KDRV_ARM_GENERIC_TIMER, &timer_driver, |
| sizeof(timer_driver)); |
| |
| // add platform ID |
| zircon_append_boot_item(zbi, ZBI_TYPE_PLATFORM_ID, 0, &platform_id, sizeof(platform_id)); |
| |
| add_partition_map(zbi); |
| // add_eth_mac_address(zbi); |
| return 0; |
| } |
