Loading...
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
10static efi_guid_t cpu_state_guid = LINUX_EFI_ARM_CPU_STATE_TABLE_GUID;
11
12struct efi_arm_entry_state *efi_entry_state;
13
14static 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
23efi_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
66drop_table:
67 efi_bs_call(install_configuration_table, &cpu_state_guid, NULL);
68free_state:
69 efi_bs_call(free_pool, efi_entry_state);
70 return status;
71}
72
73void 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
79efi_status_t handle_kernel_image(unsigned long *image_addr,
80 unsigned long *image_size,
81 unsigned long *reserve_addr,
82 unsigned long *reserve_size,
83 efi_loaded_image_t *image,
84 efi_handle_t image_handle)
85{
86 const int slack = TEXT_OFFSET - 5 * PAGE_SIZE;
87 int alloc_size = MAX_UNCOMP_KERNEL_SIZE + EFI_PHYS_ALIGN;
88 unsigned long alloc_base, kernel_base;
89 efi_status_t status;
90
91 /*
92 * Allocate space for the decompressed kernel as low as possible.
93 * The region should be 16 MiB aligned, but the first 'slack' bytes
94 * are not used by Linux, so we allow those to be occupied by the
95 * firmware.
96 */
97 status = efi_low_alloc_above(alloc_size, EFI_PAGE_SIZE, &alloc_base, 0x0);
98 if (status != EFI_SUCCESS) {
99 efi_err("Unable to allocate memory for uncompressed kernel.\n");
100 return status;
101 }
102
103 if ((alloc_base % EFI_PHYS_ALIGN) > slack) {
104 /*
105 * More than 'slack' bytes are already occupied at the base of
106 * the allocation, so we need to advance to the next 16 MiB block.
107 */
108 kernel_base = round_up(alloc_base, EFI_PHYS_ALIGN);
109 efi_info("Free memory starts at 0x%lx, setting kernel_base to 0x%lx\n",
110 alloc_base, kernel_base);
111 } else {
112 kernel_base = round_down(alloc_base, EFI_PHYS_ALIGN);
113 }
114
115 *reserve_addr = kernel_base + slack;
116 *reserve_size = MAX_UNCOMP_KERNEL_SIZE;
117
118 /* now free the parts that we will not use */
119 if (*reserve_addr > alloc_base) {
120 efi_bs_call(free_pages, alloc_base,
121 (*reserve_addr - alloc_base) / EFI_PAGE_SIZE);
122 alloc_size -= *reserve_addr - alloc_base;
123 }
124 efi_bs_call(free_pages, *reserve_addr + MAX_UNCOMP_KERNEL_SIZE,
125 (alloc_size - MAX_UNCOMP_KERNEL_SIZE) / EFI_PAGE_SIZE);
126
127 *image_addr = kernel_base + TEXT_OFFSET;
128 *image_size = 0;
129
130 efi_debug("image addr == 0x%lx, reserve_addr == 0x%lx\n",
131 *image_addr, *reserve_addr);
132
133 return EFI_SUCCESS;
134}
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
14efi_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
31static efi_guid_t screen_info_guid = LINUX_EFI_ARM_SCREEN_INFO_TABLE_GUID;
32
33struct 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
59void 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
68static 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;
189out:
190 efi_call_early(free_pool, memory_map);
191 return status;
192}
193
194efi_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}