xref: /openbmc/linux/drivers/firmware/efi/libstub/fdt.c (revision 8365a898)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
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.
6  *
7  * Copyright 2013 Linaro Limited; author Roy Franz
8  */
9 
10 #include <linux/efi.h>
11 #include <linux/libfdt.h>
12 #include <asm/efi.h>
13 
14 #include "efistub.h"
15 
16 #define EFI_DT_ADDR_CELLS_DEFAULT 2
17 #define EFI_DT_SIZE_CELLS_DEFAULT 2
18 
19 static void fdt_update_cell_size(void *fdt)
20 {
21 	int offset;
22 
23 	offset = fdt_path_offset(fdt, "/");
24 	/* Set the #address-cells and #size-cells values for an empty tree */
25 
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);
28 }
29 
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)
33 {
34 	int node, num_rsv;
35 	int status;
36 	u32 fdt_val32;
37 	u64 fdt_val64;
38 
39 	/* Do some checks on provided FDT, if it exists: */
40 	if (orig_fdt) {
41 		if (fdt_check_header(orig_fdt)) {
42 			efi_err("Device Tree header not valid!\n");
43 			return EFI_LOAD_ERROR;
44 		}
45 		/*
46 		 * We don't get the size of the FDT if we get if from a
47 		 * configuration table:
48 		 */
49 		if (orig_fdt_size && fdt_totalsize(orig_fdt) > orig_fdt_size) {
50 			efi_err("Truncated device tree! foo!\n");
51 			return EFI_LOAD_ERROR;
52 		}
53 	}
54 
55 	if (orig_fdt) {
56 		status = fdt_open_into(orig_fdt, fdt, new_fdt_size);
57 	} else {
58 		status = fdt_create_empty_tree(fdt, new_fdt_size);
59 		if (status == 0) {
60 			/*
61 			 * Any failure from the following function is
62 			 * non-critical:
63 			 */
64 			fdt_update_cell_size(fdt);
65 		}
66 	}
67 
68 	if (status != 0)
69 		goto fdt_set_fail;
70 
71 	/*
72 	 * Delete all memory reserve map entries. When booting via UEFI,
73 	 * kernel will use the UEFI memory map to find reserved regions.
74 	 */
75 	num_rsv = fdt_num_mem_rsv(fdt);
76 	while (num_rsv-- > 0)
77 		fdt_del_mem_rsv(fdt, num_rsv);
78 
79 	node = fdt_subnode_offset(fdt, 0, "chosen");
80 	if (node < 0) {
81 		node = fdt_add_subnode(fdt, 0, "chosen");
82 		if (node < 0) {
83 			/* 'node' is an error code when negative: */
84 			status = node;
85 			goto fdt_set_fail;
86 		}
87 	}
88 
89 	if (cmdline_ptr != NULL && strlen(cmdline_ptr) > 0) {
90 		status = fdt_setprop(fdt, node, "bootargs", cmdline_ptr,
91 				     strlen(cmdline_ptr) + 1);
92 		if (status)
93 			goto fdt_set_fail;
94 	}
95 
96 	/* Set initrd address/end in device tree, if present */
97 	if (initrd_size != 0) {
98 		u64 initrd_image_end;
99 		u64 initrd_image_start = cpu_to_fdt64(initrd_addr);
100 
101 		status = fdt_setprop_var(fdt, node, "linux,initrd-start", initrd_image_start);
102 		if (status)
103 			goto fdt_set_fail;
104 
105 		initrd_image_end = cpu_to_fdt64(initrd_addr + initrd_size);
106 		status = fdt_setprop_var(fdt, node, "linux,initrd-end", initrd_image_end);
107 		if (status)
108 			goto fdt_set_fail;
109 	}
110 
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);
114 
115 	status = fdt_setprop_var(fdt, node, "linux,uefi-system-table", fdt_val64);
116 	if (status)
117 		goto fdt_set_fail;
118 
119 	fdt_val64 = U64_MAX; /* placeholder */
120 
121 	status = fdt_setprop_var(fdt, node, "linux,uefi-mmap-start", fdt_val64);
122 	if (status)
123 		goto fdt_set_fail;
124 
125 	fdt_val32 = U32_MAX; /* placeholder */
126 
127 	status = fdt_setprop_var(fdt, node, "linux,uefi-mmap-size", fdt_val32);
128 	if (status)
129 		goto fdt_set_fail;
130 
131 	status = fdt_setprop_var(fdt, node, "linux,uefi-mmap-desc-size", fdt_val32);
132 	if (status)
133 		goto fdt_set_fail;
134 
135 	status = fdt_setprop_var(fdt, node, "linux,uefi-mmap-desc-ver", fdt_val32);
136 	if (status)
137 		goto fdt_set_fail;
138 
139 	if (IS_ENABLED(CONFIG_RANDOMIZE_BASE)) {
140 		efi_status_t efi_status;
141 
142 		efi_status = efi_get_random_bytes(sizeof(fdt_val64),
143 						  (u8 *)&fdt_val64);
144 		if (efi_status == EFI_SUCCESS) {
145 			status = fdt_setprop_var(fdt, node, "kaslr-seed", fdt_val64);
146 			if (status)
147 				goto fdt_set_fail;
148 		} else if (efi_status != EFI_NOT_FOUND) {
149 			return efi_status;
150 		}
151 	}
152 
153 	/* Shrink the FDT back to its minimum size: */
154 	fdt_pack(fdt);
155 
156 	return EFI_SUCCESS;
157 
158 fdt_set_fail:
159 	if (status == -FDT_ERR_NOSPACE)
160 		return EFI_BUFFER_TOO_SMALL;
161 
162 	return EFI_LOAD_ERROR;
163 }
164 
165 static efi_status_t update_fdt_memmap(void *fdt, struct efi_boot_memmap *map)
166 {
167 	int node = fdt_path_offset(fdt, "/chosen");
168 	u64 fdt_val64;
169 	u32 fdt_val32;
170 	int err;
171 
172 	if (node < 0)
173 		return EFI_LOAD_ERROR;
174 
175 	fdt_val64 = cpu_to_fdt64((unsigned long)*map->map);
176 
177 	err = fdt_setprop_inplace_var(fdt, node, "linux,uefi-mmap-start", fdt_val64);
178 	if (err)
179 		return EFI_LOAD_ERROR;
180 
181 	fdt_val32 = cpu_to_fdt32(*map->map_size);
182 
183 	err = fdt_setprop_inplace_var(fdt, node, "linux,uefi-mmap-size", fdt_val32);
184 	if (err)
185 		return EFI_LOAD_ERROR;
186 
187 	fdt_val32 = cpu_to_fdt32(*map->desc_size);
188 
189 	err = fdt_setprop_inplace_var(fdt, node, "linux,uefi-mmap-desc-size", fdt_val32);
190 	if (err)
191 		return EFI_LOAD_ERROR;
192 
193 	fdt_val32 = cpu_to_fdt32(*map->desc_ver);
194 
195 	err = fdt_setprop_inplace_var(fdt, node, "linux,uefi-mmap-desc-ver", fdt_val32);
196 	if (err)
197 		return EFI_LOAD_ERROR;
198 
199 	return EFI_SUCCESS;
200 }
201 
202 struct exit_boot_struct {
203 	efi_memory_desc_t	*runtime_map;
204 	int			*runtime_entry_count;
205 	void			*new_fdt_addr;
206 };
207 
208 static efi_status_t exit_boot_func(struct efi_boot_memmap *map,
209 				   void *priv)
210 {
211 	struct exit_boot_struct *p = priv;
212 	/*
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()
216 	 */
217 	efi_get_virtmap(*map->map, *map->map_size, *map->desc_size,
218 			p->runtime_map, p->runtime_entry_count);
219 
220 	return update_fdt_memmap(p->new_fdt_addr, map);
221 }
222 
223 #ifndef MAX_FDT_SIZE
224 # define MAX_FDT_SIZE SZ_2M
225 #endif
226 
227 /*
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.
239  */
240 
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,
245 					    char *cmdline_ptr,
246 					    unsigned long fdt_addr,
247 					    unsigned long fdt_size)
248 {
249 	unsigned long map_size, desc_size, buff_size;
250 	u32 desc_ver;
251 	unsigned long mmap_key;
252 	efi_memory_desc_t *memory_map, *runtime_map;
253 	efi_status_t status;
254 	int runtime_entry_count;
255 	struct efi_boot_memmap map;
256 	struct exit_boot_struct priv;
257 
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;
264 
265 	/*
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.
270 	 */
271 	status = efi_get_memory_map(&map);
272 	if (status != EFI_SUCCESS) {
273 		efi_err("Unable to retrieve UEFI memory map.\n");
274 		return status;
275 	}
276 
277 	efi_info("Exiting boot services and installing virtual address map...\n");
278 
279 	map.map = &memory_map;
280 	status = efi_allocate_pages(MAX_FDT_SIZE, new_fdt_addr, max_addr);
281 	if (status != EFI_SUCCESS) {
282 		efi_err("Unable to allocate memory for new device tree.\n");
283 		goto fail;
284 	}
285 
286 	/*
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().
289 	 */
290 	status = efi_get_memory_map(&map);
291 	if (status != EFI_SUCCESS)
292 		goto fail_free_new_fdt;
293 
294 	status = update_fdt((void *)fdt_addr, fdt_size,
295 			    (void *)*new_fdt_addr, MAX_FDT_SIZE, cmdline_ptr,
296 			    initrd_addr, initrd_size);
297 
298 	if (status != EFI_SUCCESS) {
299 		efi_err("Unable to construct new device tree.\n");
300 		goto fail_free_new_fdt;
301 	}
302 
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;
307 
308 	status = efi_exit_boot_services(handle, &map, &priv, exit_boot_func);
309 
310 	if (status == EFI_SUCCESS) {
311 		efi_set_virtual_address_map_t *svam;
312 
313 		if (efi_novamap)
314 			return EFI_SUCCESS;
315 
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);
320 
321 		/*
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.
325 		 */
326 		if (status != EFI_SUCCESS) {
327 			int l;
328 
329 			/*
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
333 			 * been installed.
334 			 */
335 			for (l = 0; l < map_size; l += desc_size) {
336 				efi_memory_desc_t *p = (void *)memory_map + l;
337 
338 				if (p->attribute & EFI_MEMORY_RUNTIME)
339 					p->virt_addr = 0;
340 			}
341 		}
342 		return EFI_SUCCESS;
343 	}
344 
345 	efi_err("Exit boot services failed.\n");
346 
347 fail_free_new_fdt:
348 	efi_free(MAX_FDT_SIZE, *new_fdt_addr);
349 
350 fail:
351 	efi_system_table->boottime->free_pool(runtime_map);
352 
353 	return EFI_LOAD_ERROR;
354 }
355 
356 void *get_fdt(unsigned long *fdt_size)
357 {
358 	void *fdt;
359 
360 	fdt = get_efi_config_table(DEVICE_TREE_GUID);
361 
362 	if (!fdt)
363 		return NULL;
364 
365 	if (fdt_check_header(fdt) != 0) {
366 		efi_err("Invalid header detected on UEFI supplied FDT, ignoring ...\n");
367 		return NULL;
368 	}
369 	*fdt_size = fdt_totalsize(fdt);
370 	return fdt;
371 }
372