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