1 /* 2 * Copyright (c) 2017-2024, Arm Limited and Contributors. All rights reserved. 3 * 4 * SPDX-License-Identifier: BSD-3-Clause 5 */ 6 7 #include <assert.h> 8 9 #include <libfdt.h> 10 11 #include <platform_def.h> 12 13 #include <arch.h> 14 #include <arch_helpers.h> 15 #include <common/debug.h> 16 #include <common/fdt_fixup.h> 17 #include <common/fdt_wrappers.h> 18 #include <drivers/arm/gicv2.h> 19 #include <drivers/console.h> 20 #include <drivers/generic_delay_timer.h> 21 #include <drivers/ti/uart/uart_16550.h> 22 #include <lib/mmio.h> 23 #include <plat/common/platform.h> 24 25 #include <sunxi_def.h> 26 #include <sunxi_mmap.h> 27 #include <sunxi_private.h> 28 29 30 static entry_point_info_t bl32_image_ep_info; 31 static entry_point_info_t bl33_image_ep_info; 32 33 static console_t console; 34 35 static void *fdt; 36 37 static const gicv2_driver_data_t sunxi_gic_data = { 38 .gicd_base = SUNXI_GICD_BASE, 39 .gicc_base = SUNXI_GICC_BASE, 40 }; 41 42 /* 43 * Try to find a DTB loaded in memory by previous stages. 44 * 45 * At the moment we implement a heuristic to find the DTB attached to U-Boot: 46 * U-Boot appends its DTB to the end of the image. Assuming that BL33 is 47 * U-Boot, try to find the size of the U-Boot image to learn the DTB address. 48 * The generic ARMv8 U-Boot image contains the load address and its size 49 * as u64 variables at the beginning of the image. There might be padding 50 * or other headers before that data, so scan the first 2KB after the BL33 51 * entry point to find the load address, which should be followed by the 52 * size. Adding those together gives us the address of the DTB. 53 */ 54 static void sunxi_find_dtb(void) 55 { 56 uint64_t *u_boot_base; 57 int i; 58 59 u_boot_base = (void *)SUNXI_BL33_VIRT_BASE; 60 61 for (i = 0; i < 2048 / sizeof(uint64_t); i++) { 62 void *dtb_base; 63 64 if (u_boot_base[i] != PRELOADED_BL33_BASE) 65 continue; 66 67 /* Does the suspected U-Boot size look anyhow reasonable? */ 68 if (u_boot_base[i + 1] >= 256 * 1024 * 1024) 69 continue; 70 71 /* end of the image: base address + size */ 72 dtb_base = (char *)u_boot_base + u_boot_base[i + 1]; 73 74 if (fdt_check_header(dtb_base) == 0) { 75 fdt = dtb_base; 76 return; 77 } 78 } 79 } 80 81 void bl31_early_platform_setup2(u_register_t arg0, u_register_t arg1, 82 u_register_t arg2, u_register_t arg3) 83 { 84 /* Initialize the debug console as soon as possible */ 85 console_16550_register(SUNXI_UART0_BASE, SUNXI_UART0_CLK_IN_HZ, 86 SUNXI_UART0_BAUDRATE, &console); 87 88 #ifdef BL32_BASE 89 /* Populate entry point information for BL32 */ 90 SET_PARAM_HEAD(&bl32_image_ep_info, PARAM_EP, VERSION_1, 0); 91 SET_SECURITY_STATE(bl32_image_ep_info.h.attr, SECURE); 92 bl32_image_ep_info.pc = BL32_BASE; 93 #endif 94 95 /* Populate entry point information for BL33 */ 96 SET_PARAM_HEAD(&bl33_image_ep_info, PARAM_EP, VERSION_1, 0); 97 /* 98 * Tell BL31 where the non-trusted software image 99 * is located and the entry state information 100 */ 101 bl33_image_ep_info.pc = PRELOADED_BL33_BASE; 102 bl33_image_ep_info.spsr = SPSR_64(MODE_EL2, MODE_SP_ELX, 103 DISABLE_ALL_EXCEPTIONS); 104 SET_SECURITY_STATE(bl33_image_ep_info.h.attr, NON_SECURE); 105 } 106 107 void bl31_plat_arch_setup(void) 108 { 109 sunxi_configure_mmu_el3(0); 110 } 111 112 void bl31_platform_setup(void) 113 { 114 const char *soc_name; 115 uint16_t soc_id = sunxi_read_soc_id(); 116 117 switch (soc_id) { 118 case SUNXI_SOC_A64: 119 soc_name = "A64/H64/R18"; 120 break; 121 case SUNXI_SOC_H5: 122 soc_name = "H5"; 123 break; 124 case SUNXI_SOC_H6: 125 soc_name = "H6"; 126 break; 127 case SUNXI_SOC_H616: 128 soc_name = "H616"; 129 break; 130 case SUNXI_SOC_R329: 131 soc_name = "R329"; 132 break; 133 default: 134 soc_name = "unknown"; 135 break; 136 } 137 NOTICE("BL31: Detected Allwinner %s SoC (%04x)\n", soc_name, soc_id); 138 139 generic_delay_timer_init(); 140 141 sunxi_find_dtb(); 142 if (fdt) { 143 const char *model; 144 int length; 145 146 model = fdt_getprop(fdt, 0, "model", &length); 147 NOTICE("BL31: Found U-Boot DTB at %p, model: %s\n", fdt, 148 model ?: "unknown"); 149 } else { 150 NOTICE("BL31: No DTB found.\n"); 151 } 152 153 /* Configure the interrupt controller */ 154 gicv2_driver_init(&sunxi_gic_data); 155 gicv2_distif_init(); 156 gicv2_pcpu_distif_init(); 157 gicv2_cpuif_enable(); 158 159 sunxi_security_setup(); 160 161 /* 162 * On the A64 U-Boot's SPL sets the bus clocks to some conservative 163 * values, to work around FEL mode instabilities with SRAM C accesses. 164 * FEL mode is gone when we reach ATF, so bring the AHB1 bus 165 * (the "main" bus) clock frequency back to the recommended 200MHz, 166 * for improved performance. 167 */ 168 if (soc_id == SUNXI_SOC_A64) 169 mmio_write_32(SUNXI_CCU_BASE + 0x54, 0x00003180); 170 171 /* 172 * U-Boot or the kernel don't setup AHB2, which leaves it at the 173 * AHB1 frequency (200 MHz, see above). However Allwinner recommends 174 * 300 MHz, for improved Ethernet and USB performance. Switch the 175 * clock to use "PLL_PERIPH0 / 2". 176 */ 177 if (soc_id == SUNXI_SOC_A64 || soc_id == SUNXI_SOC_H5) 178 mmio_write_32(SUNXI_CCU_BASE + 0x5c, 0x1); 179 180 sunxi_pmic_setup(soc_id, fdt); 181 182 INFO("BL31: Platform setup done\n"); 183 } 184 185 void bl31_plat_runtime_setup(void) 186 { 187 /* Change the DTB if the configuration requires so. */ 188 sunxi_prepare_dtb(fdt); 189 190 console_flush(); 191 console_switch_state(CONSOLE_FLAG_RUNTIME); 192 } 193 194 entry_point_info_t *bl31_plat_get_next_image_ep_info(uint32_t type) 195 { 196 assert(sec_state_is_valid(type) != 0); 197 198 if (type == NON_SECURE) 199 return &bl33_image_ep_info; 200 201 if ((type == SECURE) && bl32_image_ep_info.pc) 202 return &bl32_image_ep_info; 203 204 return NULL; 205 } 206