1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (C) 2013 Linaro Ltd; <roy.franz@linaro.org> 4 */ 5 #include <linux/efi.h> 6 #include <asm/efi.h> 7 8 #include "efistub.h" 9 10 static efi_guid_t cpu_state_guid = LINUX_EFI_ARM_CPU_STATE_TABLE_GUID; 11 12 struct efi_arm_entry_state *efi_entry_state; 13 14 static void get_cpu_state(u32 *cpsr, u32 *sctlr) 15 { 16 asm("mrs %0, cpsr" : "=r"(*cpsr)); 17 if ((*cpsr & MODE_MASK) == HYP_MODE) 18 asm("mrc p15, 4, %0, c1, c0, 0" : "=r"(*sctlr)); 19 else 20 asm("mrc p15, 0, %0, c1, c0, 0" : "=r"(*sctlr)); 21 } 22 23 efi_status_t check_platform_features(void) 24 { 25 efi_status_t status; 26 u32 cpsr, sctlr; 27 int block; 28 29 get_cpu_state(&cpsr, &sctlr); 30 31 efi_info("Entering in %s mode with MMU %sabled\n", 32 ((cpsr & MODE_MASK) == HYP_MODE) ? "HYP" : "SVC", 33 (sctlr & 1) ? "en" : "dis"); 34 35 status = efi_bs_call(allocate_pool, EFI_LOADER_DATA, 36 sizeof(*efi_entry_state), 37 (void **)&efi_entry_state); 38 if (status != EFI_SUCCESS) { 39 efi_err("allocate_pool() failed\n"); 40 return status; 41 } 42 43 efi_entry_state->cpsr_before_ebs = cpsr; 44 efi_entry_state->sctlr_before_ebs = sctlr; 45 46 status = efi_bs_call(install_configuration_table, &cpu_state_guid, 47 efi_entry_state); 48 if (status != EFI_SUCCESS) { 49 efi_err("install_configuration_table() failed\n"); 50 goto free_state; 51 } 52 53 /* non-LPAE kernels can run anywhere */ 54 if (!IS_ENABLED(CONFIG_ARM_LPAE)) 55 return EFI_SUCCESS; 56 57 /* LPAE kernels need compatible hardware */ 58 block = cpuid_feature_extract(CPUID_EXT_MMFR0, 0); 59 if (block < 5) { 60 efi_err("This LPAE kernel is not supported by your CPU\n"); 61 status = EFI_UNSUPPORTED; 62 goto drop_table; 63 } 64 return EFI_SUCCESS; 65 66 drop_table: 67 efi_bs_call(install_configuration_table, &cpu_state_guid, NULL); 68 free_state: 69 efi_bs_call(free_pool, efi_entry_state); 70 return status; 71 } 72 73 void efi_handle_post_ebs_state(void) 74 { 75 get_cpu_state(&efi_entry_state->cpsr_after_ebs, 76 &efi_entry_state->sctlr_after_ebs); 77 } 78 79 static efi_guid_t screen_info_guid = LINUX_EFI_ARM_SCREEN_INFO_TABLE_GUID; 80 81 struct screen_info *alloc_screen_info(void) 82 { 83 struct screen_info *si; 84 efi_status_t status; 85 86 /* 87 * Unlike on arm64, where we can directly fill out the screen_info 88 * structure from the stub, we need to allocate a buffer to hold 89 * its contents while we hand over to the kernel proper from the 90 * decompressor. 91 */ 92 status = efi_bs_call(allocate_pool, EFI_RUNTIME_SERVICES_DATA, 93 sizeof(*si), (void **)&si); 94 95 if (status != EFI_SUCCESS) 96 return NULL; 97 98 status = efi_bs_call(install_configuration_table, 99 &screen_info_guid, si); 100 if (status == EFI_SUCCESS) 101 return si; 102 103 efi_bs_call(free_pool, si); 104 return NULL; 105 } 106 107 void free_screen_info(struct screen_info *si) 108 { 109 if (!si) 110 return; 111 112 efi_bs_call(install_configuration_table, &screen_info_guid, NULL); 113 efi_bs_call(free_pool, si); 114 } 115 116 static efi_status_t reserve_kernel_base(unsigned long dram_base, 117 unsigned long *reserve_addr, 118 unsigned long *reserve_size) 119 { 120 efi_physical_addr_t alloc_addr; 121 efi_memory_desc_t *memory_map; 122 unsigned long nr_pages, map_size, desc_size, buff_size; 123 efi_status_t status; 124 unsigned long l; 125 126 struct efi_boot_memmap map = { 127 .map = &memory_map, 128 .map_size = &map_size, 129 .desc_size = &desc_size, 130 .desc_ver = NULL, 131 .key_ptr = NULL, 132 .buff_size = &buff_size, 133 }; 134 135 /* 136 * Reserve memory for the uncompressed kernel image. This is 137 * all that prevents any future allocations from conflicting 138 * with the kernel. Since we can't tell from the compressed 139 * image how much DRAM the kernel actually uses (due to BSS 140 * size uncertainty) we allocate the maximum possible size. 141 * Do this very early, as prints can cause memory allocations 142 * that may conflict with this. 143 */ 144 alloc_addr = dram_base + MAX_UNCOMP_KERNEL_SIZE; 145 nr_pages = MAX_UNCOMP_KERNEL_SIZE / EFI_PAGE_SIZE; 146 status = efi_bs_call(allocate_pages, EFI_ALLOCATE_MAX_ADDRESS, 147 EFI_BOOT_SERVICES_DATA, nr_pages, &alloc_addr); 148 if (status == EFI_SUCCESS) { 149 if (alloc_addr == dram_base) { 150 *reserve_addr = alloc_addr; 151 *reserve_size = MAX_UNCOMP_KERNEL_SIZE; 152 return EFI_SUCCESS; 153 } 154 /* 155 * If we end up here, the allocation succeeded but starts below 156 * dram_base. This can only occur if the real base of DRAM is 157 * not a multiple of 128 MB, in which case dram_base will have 158 * been rounded up. Since this implies that a part of the region 159 * was already occupied, we need to fall through to the code 160 * below to ensure that the existing allocations don't conflict. 161 * For this reason, we use EFI_BOOT_SERVICES_DATA above and not 162 * EFI_LOADER_DATA, which we wouldn't able to distinguish from 163 * allocations that we want to disallow. 164 */ 165 } 166 167 /* 168 * If the allocation above failed, we may still be able to proceed: 169 * if the only allocations in the region are of types that will be 170 * released to the OS after ExitBootServices(), the decompressor can 171 * safely overwrite them. 172 */ 173 status = efi_get_memory_map(&map); 174 if (status != EFI_SUCCESS) { 175 efi_err("reserve_kernel_base(): Unable to retrieve memory map.\n"); 176 return status; 177 } 178 179 for (l = 0; l < map_size; l += desc_size) { 180 efi_memory_desc_t *desc; 181 u64 start, end; 182 183 desc = (void *)memory_map + l; 184 start = desc->phys_addr; 185 end = start + desc->num_pages * EFI_PAGE_SIZE; 186 187 /* Skip if entry does not intersect with region */ 188 if (start >= dram_base + MAX_UNCOMP_KERNEL_SIZE || 189 end <= dram_base) 190 continue; 191 192 switch (desc->type) { 193 case EFI_BOOT_SERVICES_CODE: 194 case EFI_BOOT_SERVICES_DATA: 195 /* Ignore types that are released to the OS anyway */ 196 continue; 197 198 case EFI_CONVENTIONAL_MEMORY: 199 /* Skip soft reserved conventional memory */ 200 if (efi_soft_reserve_enabled() && 201 (desc->attribute & EFI_MEMORY_SP)) 202 continue; 203 204 /* 205 * Reserve the intersection between this entry and the 206 * region. 207 */ 208 start = max(start, (u64)dram_base); 209 end = min(end, (u64)dram_base + MAX_UNCOMP_KERNEL_SIZE); 210 211 status = efi_bs_call(allocate_pages, 212 EFI_ALLOCATE_ADDRESS, 213 EFI_LOADER_DATA, 214 (end - start) / EFI_PAGE_SIZE, 215 &start); 216 if (status != EFI_SUCCESS) { 217 efi_err("reserve_kernel_base(): alloc failed.\n"); 218 goto out; 219 } 220 break; 221 222 case EFI_LOADER_CODE: 223 case EFI_LOADER_DATA: 224 /* 225 * These regions may be released and reallocated for 226 * another purpose (including EFI_RUNTIME_SERVICE_DATA) 227 * at any time during the execution of the OS loader, 228 * so we cannot consider them as safe. 229 */ 230 default: 231 /* 232 * Treat any other allocation in the region as unsafe */ 233 status = EFI_OUT_OF_RESOURCES; 234 goto out; 235 } 236 } 237 238 status = EFI_SUCCESS; 239 out: 240 efi_bs_call(free_pool, memory_map); 241 return status; 242 } 243 244 efi_status_t handle_kernel_image(unsigned long *image_addr, 245 unsigned long *image_size, 246 unsigned long *reserve_addr, 247 unsigned long *reserve_size, 248 unsigned long dram_base, 249 efi_loaded_image_t *image) 250 { 251 unsigned long kernel_base; 252 efi_status_t status; 253 254 /* use a 16 MiB aligned base for the decompressed kernel */ 255 kernel_base = round_up(dram_base, SZ_16M) + TEXT_OFFSET; 256 257 /* 258 * Note that some platforms (notably, the Raspberry Pi 2) put 259 * spin-tables and other pieces of firmware at the base of RAM, 260 * abusing the fact that the window of TEXT_OFFSET bytes at the 261 * base of the kernel image is only partially used at the moment. 262 * (Up to 5 pages are used for the swapper page tables) 263 */ 264 status = reserve_kernel_base(kernel_base - 5 * PAGE_SIZE, reserve_addr, 265 reserve_size); 266 if (status != EFI_SUCCESS) { 267 efi_err("Unable to allocate memory for uncompressed kernel.\n"); 268 return status; 269 } 270 271 *image_addr = kernel_base; 272 *image_size = 0; 273 return EFI_SUCCESS; 274 } 275