blob: db2ae19f590d1beacfb104533e5807bf7c93b2a2 [file] [log] [blame]
Alexander Graf5d009952016-03-04 01:10:04 +01001/*
2 * EFI application memory management
3 *
4 * Copyright (c) 2016 Alexander Graf
5 *
6 * SPDX-License-Identifier: GPL-2.0+
7 */
8
Alexander Graf5d009952016-03-04 01:10:04 +01009#include <common.h>
10#include <efi_loader.h>
11#include <malloc.h>
12#include <asm/global_data.h>
13#include <libfdt_env.h>
Alexander Graf38ce65e2016-03-30 16:38:29 +020014#include <linux/list_sort.h>
Alexander Graf5d009952016-03-04 01:10:04 +010015#include <inttypes.h>
16#include <watchdog.h>
17
18DECLARE_GLOBAL_DATA_PTR;
19
20struct efi_mem_list {
21 struct list_head link;
22 struct efi_mem_desc desc;
23};
24
Alexander Graf74c16ac2016-05-27 12:25:03 +020025#define EFI_CARVE_NO_OVERLAP -1
26#define EFI_CARVE_LOOP_AGAIN -2
27#define EFI_CARVE_OVERLAPS_NONRAM -3
28
Alexander Graf5d009952016-03-04 01:10:04 +010029/* This list contains all memory map items */
30LIST_HEAD(efi_mem);
31
Alexander Graf51735ae2016-05-11 18:25:48 +020032#ifdef CONFIG_EFI_LOADER_BOUNCE_BUFFER
33void *efi_bounce_buffer;
34#endif
35
Alexander Graf5d009952016-03-04 01:10:04 +010036/*
Stefan Brüns42417bc2016-10-09 22:17:26 +020037 * U-Boot services each EFI AllocatePool request as a separate
38 * (multiple) page allocation. We have to track the number of pages
39 * to be able to free the correct amount later.
40 * EFI requires 8 byte alignment for pool allocations, so we can
41 * prepend each allocation with an 64 bit header tracking the
42 * allocation size, and hand out the remainder to the caller.
43 */
44struct efi_pool_allocation {
45 u64 num_pages;
46 char data[];
47};
48
49/*
Alexander Graf38ce65e2016-03-30 16:38:29 +020050 * Sorts the memory list from highest address to lowest address
51 *
52 * When allocating memory we should always start from the highest
53 * address chunk, so sort the memory list such that the first list
54 * iterator gets the highest address and goes lower from there.
55 */
56static int efi_mem_cmp(void *priv, struct list_head *a, struct list_head *b)
57{
58 struct efi_mem_list *mema = list_entry(a, struct efi_mem_list, link);
59 struct efi_mem_list *memb = list_entry(b, struct efi_mem_list, link);
60
61 if (mema->desc.physical_start == memb->desc.physical_start)
62 return 0;
63 else if (mema->desc.physical_start < memb->desc.physical_start)
64 return 1;
65 else
66 return -1;
67}
68
69static void efi_mem_sort(void)
70{
71 list_sort(NULL, &efi_mem, efi_mem_cmp);
72}
73
74/*
Alexander Graf5d009952016-03-04 01:10:04 +010075 * Unmaps all memory occupied by the carve_desc region from the
76 * list entry pointed to by map.
77 *
Stefan Brüns852efbf2016-10-01 23:32:23 +020078 * Returns EFI_CARVE_NO_OVERLAP if the regions don't overlap.
79 * Returns EFI_CARVE_OVERLAPS_NONRAM if the carve and map overlap,
80 * and the map contains anything but free ram.
81 * (only when overlap_only_ram is true)
82 * Returns EFI_CARVE_LOOP_AGAIN if the mapping list should be traversed
83 * again, as it has been altered
84 * Returns the number of overlapping pages. The pages are removed from
85 * the mapping list.
86 *
87 * In case of EFI_CARVE_OVERLAPS_NONRAM it is the callers responsibility
88 * to readd the already carved out pages to the mapping.
Alexander Graf5d009952016-03-04 01:10:04 +010089 */
90static int efi_mem_carve_out(struct efi_mem_list *map,
91 struct efi_mem_desc *carve_desc,
92 bool overlap_only_ram)
93{
94 struct efi_mem_list *newmap;
95 struct efi_mem_desc *map_desc = &map->desc;
96 uint64_t map_start = map_desc->physical_start;
97 uint64_t map_end = map_start + (map_desc->num_pages << EFI_PAGE_SHIFT);
98 uint64_t carve_start = carve_desc->physical_start;
99 uint64_t carve_end = carve_start +
100 (carve_desc->num_pages << EFI_PAGE_SHIFT);
101
102 /* check whether we're overlapping */
103 if ((carve_end <= map_start) || (carve_start >= map_end))
Alexander Graf74c16ac2016-05-27 12:25:03 +0200104 return EFI_CARVE_NO_OVERLAP;
Alexander Graf5d009952016-03-04 01:10:04 +0100105
106 /* We're overlapping with non-RAM, warn the caller if desired */
107 if (overlap_only_ram && (map_desc->type != EFI_CONVENTIONAL_MEMORY))
Alexander Graf74c16ac2016-05-27 12:25:03 +0200108 return EFI_CARVE_OVERLAPS_NONRAM;
Alexander Graf5d009952016-03-04 01:10:04 +0100109
110 /* Sanitize carve_start and carve_end to lie within our bounds */
111 carve_start = max(carve_start, map_start);
112 carve_end = min(carve_end, map_end);
113
114 /* Carving at the beginning of our map? Just move it! */
115 if (carve_start == map_start) {
116 if (map_end == carve_end) {
117 /* Full overlap, just remove map */
118 list_del(&map->link);
Stefan Brüns511d0b92016-10-01 23:32:29 +0200119 free(map);
120 } else {
121 map->desc.physical_start = carve_end;
122 map->desc.num_pages = (map_end - carve_end)
123 >> EFI_PAGE_SHIFT;
Alexander Graf5d009952016-03-04 01:10:04 +0100124 }
125
Alexander Graf74c16ac2016-05-27 12:25:03 +0200126 return (carve_end - carve_start) >> EFI_PAGE_SHIFT;
Alexander Graf5d009952016-03-04 01:10:04 +0100127 }
128
129 /*
130 * Overlapping maps, just split the list map at carve_start,
131 * it will get moved or removed in the next iteration.
132 *
133 * [ map_desc |__carve_start__| newmap ]
134 */
135
136 /* Create a new map from [ carve_start ... map_end ] */
137 newmap = calloc(1, sizeof(*newmap));
138 newmap->desc = map->desc;
139 newmap->desc.physical_start = carve_start;
140 newmap->desc.num_pages = (map_end - carve_start) >> EFI_PAGE_SHIFT;
Stefan Brünsb6a95172016-10-01 23:32:28 +0200141 /* Insert before current entry (descending address order) */
142 list_add_tail(&newmap->link, &map->link);
Alexander Graf5d009952016-03-04 01:10:04 +0100143
144 /* Shrink the map to [ map_start ... carve_start ] */
145 map_desc->num_pages = (carve_start - map_start) >> EFI_PAGE_SHIFT;
146
Alexander Graf74c16ac2016-05-27 12:25:03 +0200147 return EFI_CARVE_LOOP_AGAIN;
Alexander Graf5d009952016-03-04 01:10:04 +0100148}
149
150uint64_t efi_add_memory_map(uint64_t start, uint64_t pages, int memory_type,
151 bool overlap_only_ram)
152{
153 struct list_head *lhandle;
154 struct efi_mem_list *newlist;
Alexander Graf74c16ac2016-05-27 12:25:03 +0200155 bool carve_again;
156 uint64_t carved_pages = 0;
Alexander Graf5d009952016-03-04 01:10:04 +0100157
Andreas Färberc933ed92016-07-17 06:57:11 +0200158 debug("%s: 0x%" PRIx64 " 0x%" PRIx64 " %d %s\n", __func__,
159 start, pages, memory_type, overlap_only_ram ? "yes" : "no");
160
Alexander Graf5d009952016-03-04 01:10:04 +0100161 if (!pages)
162 return start;
163
164 newlist = calloc(1, sizeof(*newlist));
165 newlist->desc.type = memory_type;
166 newlist->desc.physical_start = start;
167 newlist->desc.virtual_start = start;
168 newlist->desc.num_pages = pages;
169
170 switch (memory_type) {
171 case EFI_RUNTIME_SERVICES_CODE:
172 case EFI_RUNTIME_SERVICES_DATA:
173 newlist->desc.attribute = (1 << EFI_MEMORY_WB_SHIFT) |
174 (1ULL << EFI_MEMORY_RUNTIME_SHIFT);
175 break;
176 case EFI_MMAP_IO:
177 newlist->desc.attribute = 1ULL << EFI_MEMORY_RUNTIME_SHIFT;
178 break;
179 default:
180 newlist->desc.attribute = 1 << EFI_MEMORY_WB_SHIFT;
181 break;
182 }
183
184 /* Add our new map */
185 do {
Alexander Graf74c16ac2016-05-27 12:25:03 +0200186 carve_again = false;
Alexander Graf5d009952016-03-04 01:10:04 +0100187 list_for_each(lhandle, &efi_mem) {
188 struct efi_mem_list *lmem;
189 int r;
190
191 lmem = list_entry(lhandle, struct efi_mem_list, link);
192 r = efi_mem_carve_out(lmem, &newlist->desc,
193 overlap_only_ram);
Alexander Graf74c16ac2016-05-27 12:25:03 +0200194 switch (r) {
195 case EFI_CARVE_OVERLAPS_NONRAM:
196 /*
197 * The user requested to only have RAM overlaps,
198 * but we hit a non-RAM region. Error out.
199 */
Alexander Graf5d009952016-03-04 01:10:04 +0100200 return 0;
Alexander Graf74c16ac2016-05-27 12:25:03 +0200201 case EFI_CARVE_NO_OVERLAP:
202 /* Just ignore this list entry */
203 break;
204 case EFI_CARVE_LOOP_AGAIN:
205 /*
206 * We split an entry, but need to loop through
207 * the list again to actually carve it.
208 */
209 carve_again = true;
210 break;
211 default:
212 /* We carved a number of pages */
213 carved_pages += r;
214 carve_again = true;
215 break;
216 }
217
218 if (carve_again) {
219 /* The list changed, we need to start over */
Alexander Graf5d009952016-03-04 01:10:04 +0100220 break;
221 }
222 }
Alexander Graf74c16ac2016-05-27 12:25:03 +0200223 } while (carve_again);
224
225 if (overlap_only_ram && (carved_pages != pages)) {
226 /*
227 * The payload wanted to have RAM overlaps, but we overlapped
228 * with an unallocated region. Error out.
229 */
230 return 0;
231 }
Alexander Graf5d009952016-03-04 01:10:04 +0100232
233 /* Add our new map */
234 list_add_tail(&newlist->link, &efi_mem);
235
Alexander Graf38ce65e2016-03-30 16:38:29 +0200236 /* And make sure memory is listed in descending order */
237 efi_mem_sort();
238
Alexander Graf5d009952016-03-04 01:10:04 +0100239 return start;
240}
241
242static uint64_t efi_find_free_memory(uint64_t len, uint64_t max_addr)
243{
244 struct list_head *lhandle;
245
246 list_for_each(lhandle, &efi_mem) {
247 struct efi_mem_list *lmem = list_entry(lhandle,
248 struct efi_mem_list, link);
249 struct efi_mem_desc *desc = &lmem->desc;
250 uint64_t desc_len = desc->num_pages << EFI_PAGE_SHIFT;
251 uint64_t desc_end = desc->physical_start + desc_len;
252 uint64_t curmax = min(max_addr, desc_end);
253 uint64_t ret = curmax - len;
254
255 /* We only take memory from free RAM */
256 if (desc->type != EFI_CONVENTIONAL_MEMORY)
257 continue;
258
259 /* Out of bounds for max_addr */
260 if ((ret + len) > max_addr)
261 continue;
262
263 /* Out of bounds for upper map limit */
264 if ((ret + len) > desc_end)
265 continue;
266
267 /* Out of bounds for lower map limit */
268 if (ret < desc->physical_start)
269 continue;
270
271 /* Return the highest address in this map within bounds */
272 return ret;
273 }
274
275 return 0;
276}
277
278efi_status_t efi_allocate_pages(int type, int memory_type,
279 unsigned long pages, uint64_t *memory)
280{
281 u64 len = pages << EFI_PAGE_SHIFT;
282 efi_status_t r = EFI_SUCCESS;
283 uint64_t addr;
284
285 switch (type) {
286 case 0:
287 /* Any page */
Andreas Färberdede2842016-04-13 14:04:38 +0200288 addr = efi_find_free_memory(len, gd->start_addr_sp);
Alexander Graf5d009952016-03-04 01:10:04 +0100289 if (!addr) {
290 r = EFI_NOT_FOUND;
291 break;
292 }
293 break;
294 case 1:
295 /* Max address */
296 addr = efi_find_free_memory(len, *memory);
297 if (!addr) {
298 r = EFI_NOT_FOUND;
299 break;
300 }
301 break;
302 case 2:
303 /* Exact address, reserve it. The addr is already in *memory. */
304 addr = *memory;
305 break;
306 default:
307 /* UEFI doesn't specify other allocation types */
308 r = EFI_INVALID_PARAMETER;
309 break;
310 }
311
312 if (r == EFI_SUCCESS) {
313 uint64_t ret;
314
315 /* Reserve that map in our memory maps */
316 ret = efi_add_memory_map(addr, pages, memory_type, true);
317 if (ret == addr) {
318 *memory = addr;
319 } else {
320 /* Map would overlap, bail out */
321 r = EFI_OUT_OF_RESOURCES;
322 }
323 }
324
325 return r;
326}
327
328void *efi_alloc(uint64_t len, int memory_type)
329{
330 uint64_t ret = 0;
331 uint64_t pages = (len + EFI_PAGE_MASK) >> EFI_PAGE_SHIFT;
332 efi_status_t r;
333
334 r = efi_allocate_pages(0, memory_type, pages, &ret);
335 if (r == EFI_SUCCESS)
336 return (void*)(uintptr_t)ret;
337
338 return NULL;
339}
340
341efi_status_t efi_free_pages(uint64_t memory, unsigned long pages)
342{
Stefan Brünsb61d8572016-10-01 23:32:27 +0200343 uint64_t r = 0;
344
345 r = efi_add_memory_map(memory, pages, EFI_CONVENTIONAL_MEMORY, false);
346 /* Merging of adjacent free regions is missing */
347
348 if (r == memory)
349 return EFI_SUCCESS;
350
351 return EFI_NOT_FOUND;
Alexander Graf5d009952016-03-04 01:10:04 +0100352}
353
Stefan Brünsead12742016-10-09 22:17:18 +0200354efi_status_t efi_allocate_pool(int pool_type, unsigned long size,
355 void **buffer)
356{
357 efi_status_t r;
358 efi_physical_addr_t t;
Stefan Brüns42417bc2016-10-09 22:17:26 +0200359 u64 num_pages = (size + sizeof(u64) + EFI_PAGE_MASK) >> EFI_PAGE_SHIFT;
360
361 if (size == 0) {
362 *buffer = NULL;
363 return EFI_SUCCESS;
364 }
Stefan Brünsead12742016-10-09 22:17:18 +0200365
366 r = efi_allocate_pages(0, pool_type, num_pages, &t);
Stefan Brüns42417bc2016-10-09 22:17:26 +0200367
368 if (r == EFI_SUCCESS) {
369 struct efi_pool_allocation *alloc = (void *)(uintptr_t)t;
370 alloc->num_pages = num_pages;
371 *buffer = alloc->data;
372 }
373
374 return r;
375}
376
377efi_status_t efi_free_pool(void *buffer)
378{
379 efi_status_t r;
380 struct efi_pool_allocation *alloc;
381
382 alloc = container_of(buffer, struct efi_pool_allocation, data);
383 /* Sanity check, was the supplied address returned by allocate_pool */
384 assert(((uintptr_t)alloc & EFI_PAGE_MASK) == 0);
385
386 r = efi_free_pages((uintptr_t)alloc, alloc->num_pages);
Stefan Brünsead12742016-10-09 22:17:18 +0200387
388 return r;
389}
390
Alexander Graf5d009952016-03-04 01:10:04 +0100391efi_status_t efi_get_memory_map(unsigned long *memory_map_size,
392 struct efi_mem_desc *memory_map,
393 unsigned long *map_key,
394 unsigned long *descriptor_size,
395 uint32_t *descriptor_version)
396{
397 ulong map_size = 0;
Alexander Grafcee752f2016-04-11 23:51:02 +0200398 int map_entries = 0;
Alexander Graf5d009952016-03-04 01:10:04 +0100399 struct list_head *lhandle;
Stefan Brünsbdf5c1b2016-10-09 22:17:07 +0200400 unsigned long provided_map_size = *memory_map_size;
Alexander Graf5d009952016-03-04 01:10:04 +0100401
402 list_for_each(lhandle, &efi_mem)
Alexander Grafcee752f2016-04-11 23:51:02 +0200403 map_entries++;
404
405 map_size = map_entries * sizeof(struct efi_mem_desc);
Alexander Graf5d009952016-03-04 01:10:04 +0100406
407 *memory_map_size = map_size;
408
409 if (descriptor_size)
410 *descriptor_size = sizeof(struct efi_mem_desc);
411
Mian Yousaf Kaukab4c02c112016-09-05 23:59:22 +0200412 if (descriptor_version)
413 *descriptor_version = EFI_MEMORY_DESCRIPTOR_VERSION;
414
Stefan Brünsbdf5c1b2016-10-09 22:17:07 +0200415 if (provided_map_size < map_size)
Alexander Graf5d009952016-03-04 01:10:04 +0100416 return EFI_BUFFER_TOO_SMALL;
417
418 /* Copy list into array */
419 if (memory_map) {
Alexander Grafcee752f2016-04-11 23:51:02 +0200420 /* Return the list in ascending order */
421 memory_map = &memory_map[map_entries - 1];
Alexander Graf5d009952016-03-04 01:10:04 +0100422 list_for_each(lhandle, &efi_mem) {
423 struct efi_mem_list *lmem;
424
425 lmem = list_entry(lhandle, struct efi_mem_list, link);
426 *memory_map = lmem->desc;
Alexander Grafcee752f2016-04-11 23:51:02 +0200427 memory_map--;
Alexander Graf5d009952016-03-04 01:10:04 +0100428 }
429 }
430
431 return EFI_SUCCESS;
432}
433
York Sun42633742017-03-06 09:02:27 -0800434__weak void efi_add_known_memory(void)
Alexander Graf5d009952016-03-04 01:10:04 +0100435{
Alexander Graf5d009952016-03-04 01:10:04 +0100436 int i;
437
438 /* Add RAM */
439 for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++) {
440 u64 ram_start = gd->bd->bi_dram[i].start;
441 u64 ram_size = gd->bd->bi_dram[i].size;
442 u64 start = (ram_start + EFI_PAGE_MASK) & ~EFI_PAGE_MASK;
443 u64 pages = (ram_size + EFI_PAGE_MASK) >> EFI_PAGE_SHIFT;
444
445 efi_add_memory_map(start, pages, EFI_CONVENTIONAL_MEMORY,
446 false);
447 }
York Sun42633742017-03-06 09:02:27 -0800448}
449
450int efi_memory_init(void)
451{
452 unsigned long runtime_start, runtime_end, runtime_pages;
453 unsigned long uboot_start, uboot_pages;
454 unsigned long uboot_stack_size = 16 * 1024 * 1024;
455
456 efi_add_known_memory();
Alexander Graf5d009952016-03-04 01:10:04 +0100457
458 /* Add U-Boot */
459 uboot_start = (gd->start_addr_sp - uboot_stack_size) & ~EFI_PAGE_MASK;
460 uboot_pages = (gd->ram_top - uboot_start) >> EFI_PAGE_SHIFT;
461 efi_add_memory_map(uboot_start, uboot_pages, EFI_LOADER_DATA, false);
462
463 /* Add Runtime Services */
464 runtime_start = (ulong)&__efi_runtime_start & ~EFI_PAGE_MASK;
465 runtime_end = (ulong)&__efi_runtime_stop;
466 runtime_end = (runtime_end + EFI_PAGE_MASK) & ~EFI_PAGE_MASK;
467 runtime_pages = (runtime_end - runtime_start) >> EFI_PAGE_SHIFT;
468 efi_add_memory_map(runtime_start, runtime_pages,
469 EFI_RUNTIME_SERVICES_CODE, false);
470
Alexander Graf51735ae2016-05-11 18:25:48 +0200471#ifdef CONFIG_EFI_LOADER_BOUNCE_BUFFER
472 /* Request a 32bit 64MB bounce buffer region */
473 uint64_t efi_bounce_buffer_addr = 0xffffffff;
474
475 if (efi_allocate_pages(1, EFI_LOADER_DATA,
476 (64 * 1024 * 1024) >> EFI_PAGE_SHIFT,
477 &efi_bounce_buffer_addr) != EFI_SUCCESS)
478 return -1;
479
480 efi_bounce_buffer = (void*)(uintptr_t)efi_bounce_buffer_addr;
481#endif
482
Alexander Graf5d009952016-03-04 01:10:04 +0100483 return 0;
484}