1 /* 2 * Copyright (C) 2013 Linaro Ltd; <roy.franz@linaro.org> 3 * 4 * This program is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU General Public License version 2 as 6 * published by the Free Software Foundation. 7 * 8 */ 9 #include <linux/efi.h> 10 #include <asm/efi.h> 11 12 #include "efistub.h" 13 14 efi_status_t check_platform_features(efi_system_table_t *sys_table_arg) 15 { 16 int block; 17 18 /* non-LPAE kernels can run anywhere */ 19 if (!IS_ENABLED(CONFIG_ARM_LPAE)) 20 return EFI_SUCCESS; 21 22 /* LPAE kernels need compatible hardware */ 23 block = cpuid_feature_extract(CPUID_EXT_MMFR0, 0); 24 if (block < 5) { 25 pr_efi_err(sys_table_arg, "This LPAE kernel is not supported by your CPU\n"); 26 return EFI_UNSUPPORTED; 27 } 28 return EFI_SUCCESS; 29 } 30 31 static efi_guid_t screen_info_guid = LINUX_EFI_ARM_SCREEN_INFO_TABLE_GUID; 32 33 struct screen_info *alloc_screen_info(efi_system_table_t *sys_table_arg) 34 { 35 struct screen_info *si; 36 efi_status_t status; 37 38 /* 39 * Unlike on arm64, where we can directly fill out the screen_info 40 * structure from the stub, we need to allocate a buffer to hold 41 * its contents while we hand over to the kernel proper from the 42 * decompressor. 43 */ 44 status = efi_call_early(allocate_pool, EFI_RUNTIME_SERVICES_DATA, 45 sizeof(*si), (void **)&si); 46 47 if (status != EFI_SUCCESS) 48 return NULL; 49 50 status = efi_call_early(install_configuration_table, 51 &screen_info_guid, si); 52 if (status == EFI_SUCCESS) 53 return si; 54 55 efi_call_early(free_pool, si); 56 return NULL; 57 } 58 59 void free_screen_info(efi_system_table_t *sys_table_arg, struct screen_info *si) 60 { 61 if (!si) 62 return; 63 64 efi_call_early(install_configuration_table, &screen_info_guid, NULL); 65 efi_call_early(free_pool, si); 66 } 67 68 static efi_status_t reserve_kernel_base(efi_system_table_t *sys_table_arg, 69 unsigned long dram_base, 70 unsigned long *reserve_addr, 71 unsigned long *reserve_size) 72 { 73 efi_physical_addr_t alloc_addr; 74 efi_memory_desc_t *memory_map; 75 unsigned long nr_pages, map_size, desc_size, buff_size; 76 efi_status_t status; 77 unsigned long l; 78 79 struct efi_boot_memmap map = { 80 .map = &memory_map, 81 .map_size = &map_size, 82 .desc_size = &desc_size, 83 .desc_ver = NULL, 84 .key_ptr = NULL, 85 .buff_size = &buff_size, 86 }; 87 88 /* 89 * Reserve memory for the uncompressed kernel image. This is 90 * all that prevents any future allocations from conflicting 91 * with the kernel. Since we can't tell from the compressed 92 * image how much DRAM the kernel actually uses (due to BSS 93 * size uncertainty) we allocate the maximum possible size. 94 * Do this very early, as prints can cause memory allocations 95 * that may conflict with this. 96 */ 97 alloc_addr = dram_base + MAX_UNCOMP_KERNEL_SIZE; 98 nr_pages = MAX_UNCOMP_KERNEL_SIZE / EFI_PAGE_SIZE; 99 status = efi_call_early(allocate_pages, EFI_ALLOCATE_MAX_ADDRESS, 100 EFI_BOOT_SERVICES_DATA, nr_pages, &alloc_addr); 101 if (status == EFI_SUCCESS) { 102 if (alloc_addr == dram_base) { 103 *reserve_addr = alloc_addr; 104 *reserve_size = MAX_UNCOMP_KERNEL_SIZE; 105 return EFI_SUCCESS; 106 } 107 /* 108 * If we end up here, the allocation succeeded but starts below 109 * dram_base. This can only occur if the real base of DRAM is 110 * not a multiple of 128 MB, in which case dram_base will have 111 * been rounded up. Since this implies that a part of the region 112 * was already occupied, we need to fall through to the code 113 * below to ensure that the existing allocations don't conflict. 114 * For this reason, we use EFI_BOOT_SERVICES_DATA above and not 115 * EFI_LOADER_DATA, which we wouldn't able to distinguish from 116 * allocations that we want to disallow. 117 */ 118 } 119 120 /* 121 * If the allocation above failed, we may still be able to proceed: 122 * if the only allocations in the region are of types that will be 123 * released to the OS after ExitBootServices(), the decompressor can 124 * safely overwrite them. 125 */ 126 status = efi_get_memory_map(sys_table_arg, &map); 127 if (status != EFI_SUCCESS) { 128 pr_efi_err(sys_table_arg, 129 "reserve_kernel_base(): Unable to retrieve memory map.\n"); 130 return status; 131 } 132 133 for (l = 0; l < map_size; l += desc_size) { 134 efi_memory_desc_t *desc; 135 u64 start, end; 136 137 desc = (void *)memory_map + l; 138 start = desc->phys_addr; 139 end = start + desc->num_pages * EFI_PAGE_SIZE; 140 141 /* Skip if entry does not intersect with region */ 142 if (start >= dram_base + MAX_UNCOMP_KERNEL_SIZE || 143 end <= dram_base) 144 continue; 145 146 switch (desc->type) { 147 case EFI_BOOT_SERVICES_CODE: 148 case EFI_BOOT_SERVICES_DATA: 149 /* Ignore types that are released to the OS anyway */ 150 continue; 151 152 case EFI_CONVENTIONAL_MEMORY: 153 /* 154 * Reserve the intersection between this entry and the 155 * region. 156 */ 157 start = max(start, (u64)dram_base); 158 end = min(end, (u64)dram_base + MAX_UNCOMP_KERNEL_SIZE); 159 160 status = efi_call_early(allocate_pages, 161 EFI_ALLOCATE_ADDRESS, 162 EFI_LOADER_DATA, 163 (end - start) / EFI_PAGE_SIZE, 164 &start); 165 if (status != EFI_SUCCESS) { 166 pr_efi_err(sys_table_arg, 167 "reserve_kernel_base(): alloc failed.\n"); 168 goto out; 169 } 170 break; 171 172 case EFI_LOADER_CODE: 173 case EFI_LOADER_DATA: 174 /* 175 * These regions may be released and reallocated for 176 * another purpose (including EFI_RUNTIME_SERVICE_DATA) 177 * at any time during the execution of the OS loader, 178 * so we cannot consider them as safe. 179 */ 180 default: 181 /* 182 * Treat any other allocation in the region as unsafe */ 183 status = EFI_OUT_OF_RESOURCES; 184 goto out; 185 } 186 } 187 188 status = EFI_SUCCESS; 189 out: 190 efi_call_early(free_pool, memory_map); 191 return status; 192 } 193 194 efi_status_t handle_kernel_image(efi_system_table_t *sys_table, 195 unsigned long *image_addr, 196 unsigned long *image_size, 197 unsigned long *reserve_addr, 198 unsigned long *reserve_size, 199 unsigned long dram_base, 200 efi_loaded_image_t *image) 201 { 202 efi_status_t status; 203 204 /* 205 * Verify that the DRAM base address is compatible with the ARM 206 * boot protocol, which determines the base of DRAM by masking 207 * off the low 27 bits of the address at which the zImage is 208 * loaded. These assumptions are made by the decompressor, 209 * before any memory map is available. 210 */ 211 dram_base = round_up(dram_base, SZ_128M); 212 213 status = reserve_kernel_base(sys_table, dram_base, reserve_addr, 214 reserve_size); 215 if (status != EFI_SUCCESS) { 216 pr_efi_err(sys_table, "Unable to allocate memory for uncompressed kernel.\n"); 217 return status; 218 } 219 220 /* 221 * Relocate the zImage, so that it appears in the lowest 128 MB 222 * memory window. 223 */ 224 *image_size = image->image_size; 225 status = efi_relocate_kernel(sys_table, image_addr, *image_size, 226 *image_size, 227 dram_base + MAX_UNCOMP_KERNEL_SIZE, 0); 228 if (status != EFI_SUCCESS) { 229 pr_efi_err(sys_table, "Failed to relocate kernel.\n"); 230 efi_free(sys_table, *reserve_size, *reserve_addr); 231 *reserve_size = 0; 232 return status; 233 } 234 235 /* 236 * Check to see if we were able to allocate memory low enough 237 * in memory. The kernel determines the base of DRAM from the 238 * address at which the zImage is loaded. 239 */ 240 if (*image_addr + *image_size > dram_base + ZIMAGE_OFFSET_LIMIT) { 241 pr_efi_err(sys_table, "Failed to relocate kernel, no low memory available.\n"); 242 efi_free(sys_table, *reserve_size, *reserve_addr); 243 *reserve_size = 0; 244 efi_free(sys_table, *image_size, *image_addr); 245 *image_size = 0; 246 return EFI_LOAD_ERROR; 247 } 248 return EFI_SUCCESS; 249 } 250