1 // SPDX-License-Identifier: GPL-2.0
3 * FDT related Helper functions used by the EFI stub on multiple
4 * architectures. This should be #included by the EFI stub
5 * implementation files.
7 * Copyright 2013 Linaro Limited; author Roy Franz
10 #include <linux/efi.h>
11 #include <linux/libfdt.h>
16 #define EFI_DT_ADDR_CELLS_DEFAULT 2
17 #define EFI_DT_SIZE_CELLS_DEFAULT 2
19 static void fdt_update_cell_size(void *fdt
)
23 offset
= fdt_path_offset(fdt
, "/");
24 /* Set the #address-cells and #size-cells values for an empty tree */
26 fdt_setprop_u32(fdt
, offset
, "#address-cells", EFI_DT_ADDR_CELLS_DEFAULT
);
27 fdt_setprop_u32(fdt
, offset
, "#size-cells", EFI_DT_SIZE_CELLS_DEFAULT
);
30 static efi_status_t
update_fdt(void *orig_fdt
, unsigned long orig_fdt_size
,
31 void *fdt
, int new_fdt_size
, char *cmdline_ptr
,
32 u64 initrd_addr
, u64 initrd_size
)
39 /* Do some checks on provided FDT, if it exists: */
41 if (fdt_check_header(orig_fdt
)) {
42 pr_efi_err("Device Tree header not valid!\n");
43 return EFI_LOAD_ERROR
;
46 * We don't get the size of the FDT if we get if from a
47 * configuration table:
49 if (orig_fdt_size
&& fdt_totalsize(orig_fdt
) > orig_fdt_size
) {
50 pr_efi_err("Truncated device tree! foo!\n");
51 return EFI_LOAD_ERROR
;
56 status
= fdt_open_into(orig_fdt
, fdt
, new_fdt_size
);
58 status
= fdt_create_empty_tree(fdt
, new_fdt_size
);
61 * Any failure from the following function is
64 fdt_update_cell_size(fdt
);
72 * Delete all memory reserve map entries. When booting via UEFI,
73 * kernel will use the UEFI memory map to find reserved regions.
75 num_rsv
= fdt_num_mem_rsv(fdt
);
77 fdt_del_mem_rsv(fdt
, num_rsv
);
79 node
= fdt_subnode_offset(fdt
, 0, "chosen");
81 node
= fdt_add_subnode(fdt
, 0, "chosen");
83 /* 'node' is an error code when negative: */
89 if (cmdline_ptr
!= NULL
&& strlen(cmdline_ptr
) > 0) {
90 status
= fdt_setprop(fdt
, node
, "bootargs", cmdline_ptr
,
91 strlen(cmdline_ptr
) + 1);
96 /* Set initrd address/end in device tree, if present */
97 if (initrd_size
!= 0) {
99 u64 initrd_image_start
= cpu_to_fdt64(initrd_addr
);
101 status
= fdt_setprop_var(fdt
, node
, "linux,initrd-start", initrd_image_start
);
105 initrd_image_end
= cpu_to_fdt64(initrd_addr
+ initrd_size
);
106 status
= fdt_setprop_var(fdt
, node
, "linux,initrd-end", initrd_image_end
);
111 /* Add FDT entries for EFI runtime services in chosen node. */
112 node
= fdt_subnode_offset(fdt
, 0, "chosen");
113 fdt_val64
= cpu_to_fdt64((u64
)(unsigned long)efi_system_table());
115 status
= fdt_setprop_var(fdt
, node
, "linux,uefi-system-table", fdt_val64
);
119 fdt_val64
= U64_MAX
; /* placeholder */
121 status
= fdt_setprop_var(fdt
, node
, "linux,uefi-mmap-start", fdt_val64
);
125 fdt_val32
= U32_MAX
; /* placeholder */
127 status
= fdt_setprop_var(fdt
, node
, "linux,uefi-mmap-size", fdt_val32
);
131 status
= fdt_setprop_var(fdt
, node
, "linux,uefi-mmap-desc-size", fdt_val32
);
135 status
= fdt_setprop_var(fdt
, node
, "linux,uefi-mmap-desc-ver", fdt_val32
);
139 if (IS_ENABLED(CONFIG_RANDOMIZE_BASE
)) {
140 efi_status_t efi_status
;
142 efi_status
= efi_get_random_bytes(sizeof(fdt_val64
),
144 if (efi_status
== EFI_SUCCESS
) {
145 status
= fdt_setprop_var(fdt
, node
, "kaslr-seed", fdt_val64
);
148 } else if (efi_status
!= EFI_NOT_FOUND
) {
153 /* Shrink the FDT back to its minimum size: */
159 if (status
== -FDT_ERR_NOSPACE
)
160 return EFI_BUFFER_TOO_SMALL
;
162 return EFI_LOAD_ERROR
;
165 static efi_status_t
update_fdt_memmap(void *fdt
, struct efi_boot_memmap
*map
)
167 int node
= fdt_path_offset(fdt
, "/chosen");
173 return EFI_LOAD_ERROR
;
175 fdt_val64
= cpu_to_fdt64((unsigned long)*map
->map
);
177 err
= fdt_setprop_inplace_var(fdt
, node
, "linux,uefi-mmap-start", fdt_val64
);
179 return EFI_LOAD_ERROR
;
181 fdt_val32
= cpu_to_fdt32(*map
->map_size
);
183 err
= fdt_setprop_inplace_var(fdt
, node
, "linux,uefi-mmap-size", fdt_val32
);
185 return EFI_LOAD_ERROR
;
187 fdt_val32
= cpu_to_fdt32(*map
->desc_size
);
189 err
= fdt_setprop_inplace_var(fdt
, node
, "linux,uefi-mmap-desc-size", fdt_val32
);
191 return EFI_LOAD_ERROR
;
193 fdt_val32
= cpu_to_fdt32(*map
->desc_ver
);
195 err
= fdt_setprop_inplace_var(fdt
, node
, "linux,uefi-mmap-desc-ver", fdt_val32
);
197 return EFI_LOAD_ERROR
;
202 struct exit_boot_struct
{
203 efi_memory_desc_t
*runtime_map
;
204 int *runtime_entry_count
;
208 static efi_status_t
exit_boot_func(struct efi_boot_memmap
*map
,
211 struct exit_boot_struct
*p
= priv
;
213 * Update the memory map with virtual addresses. The function will also
214 * populate @runtime_map with copies of just the EFI_MEMORY_RUNTIME
215 * entries so that we can pass it straight to SetVirtualAddressMap()
217 efi_get_virtmap(*map
->map
, *map
->map_size
, *map
->desc_size
,
218 p
->runtime_map
, p
->runtime_entry_count
);
220 return update_fdt_memmap(p
->new_fdt_addr
, map
);
224 # define MAX_FDT_SIZE SZ_2M
228 * Allocate memory for a new FDT, then add EFI, commandline, and
229 * initrd related fields to the FDT. This routine increases the
230 * FDT allocation size until the allocated memory is large
231 * enough. EFI allocations are in EFI_PAGE_SIZE granules,
232 * which are fixed at 4K bytes, so in most cases the first
233 * allocation should succeed.
234 * EFI boot services are exited at the end of this function.
235 * There must be no allocations between the get_memory_map()
236 * call and the exit_boot_services() call, so the exiting of
237 * boot services is very tightly tied to the creation of the FDT
238 * with the final memory map in it.
241 efi_status_t
allocate_new_fdt_and_exit_boot(void *handle
,
242 unsigned long *new_fdt_addr
,
243 unsigned long max_addr
,
244 u64 initrd_addr
, u64 initrd_size
,
246 unsigned long fdt_addr
,
247 unsigned long fdt_size
)
249 unsigned long map_size
, desc_size
, buff_size
;
251 unsigned long mmap_key
;
252 efi_memory_desc_t
*memory_map
, *runtime_map
;
254 int runtime_entry_count
;
255 struct efi_boot_memmap map
;
256 struct exit_boot_struct priv
;
258 map
.map
= &runtime_map
;
259 map
.map_size
= &map_size
;
260 map
.desc_size
= &desc_size
;
261 map
.desc_ver
= &desc_ver
;
262 map
.key_ptr
= &mmap_key
;
263 map
.buff_size
= &buff_size
;
266 * Get a copy of the current memory map that we will use to prepare
267 * the input for SetVirtualAddressMap(). We don't have to worry about
268 * subsequent allocations adding entries, since they could not affect
269 * the number of EFI_MEMORY_RUNTIME regions.
271 status
= efi_get_memory_map(&map
);
272 if (status
!= EFI_SUCCESS
) {
273 pr_efi_err("Unable to retrieve UEFI memory map.\n");
277 pr_efi("Exiting boot services and installing virtual address map...\n");
279 map
.map
= &memory_map
;
280 status
= efi_allocate_pages(MAX_FDT_SIZE
, new_fdt_addr
, max_addr
);
281 if (status
!= EFI_SUCCESS
) {
282 pr_efi_err("Unable to allocate memory for new device tree.\n");
287 * Now that we have done our final memory allocation (and free)
288 * we can get the memory map key needed for exit_boot_services().
290 status
= efi_get_memory_map(&map
);
291 if (status
!= EFI_SUCCESS
)
292 goto fail_free_new_fdt
;
294 status
= update_fdt((void *)fdt_addr
, fdt_size
,
295 (void *)*new_fdt_addr
, MAX_FDT_SIZE
, cmdline_ptr
,
296 initrd_addr
, initrd_size
);
298 if (status
!= EFI_SUCCESS
) {
299 pr_efi_err("Unable to construct new device tree.\n");
300 goto fail_free_new_fdt
;
303 runtime_entry_count
= 0;
304 priv
.runtime_map
= runtime_map
;
305 priv
.runtime_entry_count
= &runtime_entry_count
;
306 priv
.new_fdt_addr
= (void *)*new_fdt_addr
;
308 status
= efi_exit_boot_services(handle
, &map
, &priv
, exit_boot_func
);
310 if (status
== EFI_SUCCESS
) {
311 efi_set_virtual_address_map_t
*svam
;
316 /* Install the new virtual address map */
317 svam
= efi_system_table()->runtime
->set_virtual_address_map
;
318 status
= svam(runtime_entry_count
* desc_size
, desc_size
,
319 desc_ver
, runtime_map
);
322 * We are beyond the point of no return here, so if the call to
323 * SetVirtualAddressMap() failed, we need to signal that to the
324 * incoming kernel but proceed normally otherwise.
326 if (status
!= EFI_SUCCESS
) {
330 * Set the virtual address field of all
331 * EFI_MEMORY_RUNTIME entries to 0. This will signal
332 * the incoming kernel that no virtual translation has
335 for (l
= 0; l
< map_size
; l
+= desc_size
) {
336 efi_memory_desc_t
*p
= (void *)memory_map
+ l
;
338 if (p
->attribute
& EFI_MEMORY_RUNTIME
)
345 pr_efi_err("Exit boot services failed.\n");
348 efi_free(MAX_FDT_SIZE
, *new_fdt_addr
);
351 efi_system_table()->boottime
->free_pool(runtime_map
);
353 return EFI_LOAD_ERROR
;
356 void *get_fdt(unsigned long *fdt_size
)
360 fdt
= get_efi_config_table(DEVICE_TREE_GUID
);
365 if (fdt_check_header(fdt
) != 0) {
366 pr_efi_err("Invalid header detected on UEFI supplied FDT, ignoring ...\n");
369 *fdt_size
= fdt_totalsize(fdt
);