]>
Commit | Line | Data |
---|---|---|
f739fcd8 | 1 | // SPDX-License-Identifier: GPL-2.0+ |
5d00995c AG |
2 | /* |
3 | * EFI application memory management | |
4 | * | |
5 | * Copyright (c) 2016 Alexander Graf | |
5d00995c AG |
6 | */ |
7 | ||
5d00995c AG |
8 | #include <common.h> |
9 | #include <efi_loader.h> | |
bdecaebd | 10 | #include <inttypes.h> |
5d00995c | 11 | #include <malloc.h> |
282a06cb | 12 | #include <mapmem.h> |
bdecaebd | 13 | #include <watchdog.h> |
38ce65e1 | 14 | #include <linux/list_sort.h> |
5d00995c AG |
15 | |
16 | DECLARE_GLOBAL_DATA_PTR; | |
17 | ||
1fcb7ea2 HS |
18 | efi_uintn_t efi_memory_map_key; |
19 | ||
5d00995c AG |
20 | struct efi_mem_list { |
21 | struct list_head link; | |
22 | struct efi_mem_desc desc; | |
23 | }; | |
24 | ||
74c16acc AG |
25 | #define EFI_CARVE_NO_OVERLAP -1 |
26 | #define EFI_CARVE_LOOP_AGAIN -2 | |
27 | #define EFI_CARVE_OVERLAPS_NONRAM -3 | |
28 | ||
5d00995c AG |
29 | /* This list contains all memory map items */ |
30 | LIST_HEAD(efi_mem); | |
31 | ||
51735ae0 AG |
32 | #ifdef CONFIG_EFI_LOADER_BOUNCE_BUFFER |
33 | void *efi_bounce_buffer; | |
34 | #endif | |
35 | ||
42417bc8 SB |
36 | /* |
37 | * 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 | */ | |
44 | struct efi_pool_allocation { | |
45 | u64 num_pages; | |
946160f3 | 46 | char data[] __aligned(ARCH_DMA_MINALIGN); |
42417bc8 SB |
47 | }; |
48 | ||
38ce65e1 AG |
49 | /* |
50 | * 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 | */ | |
56 | static 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 | ||
69 | static void efi_mem_sort(void) | |
70 | { | |
71 | list_sort(NULL, &efi_mem, efi_mem_cmp); | |
72 | } | |
73 | ||
32826140 HS |
74 | /** efi_mem_carve_out - unmap memory region |
75 | * | |
76 | * @map: memory map | |
77 | * @carve_desc: memory region to unmap | |
78 | * @overlap_only_ram: the carved out region may only overlap RAM | |
79 | * Return Value: the number of overlapping pages which have been | |
80 | * removed from the map, | |
81 | * EFI_CARVE_NO_OVERLAP, if the regions don't overlap, | |
82 | * EFI_CARVE_OVERLAPS_NONRAM, if the carve and map overlap, | |
83 | * and the map contains anything but free ram | |
84 | * (only when overlap_only_ram is true), | |
85 | * EFI_CARVE_LOOP_AGAIN, if the mapping list should be | |
86 | * traversed again, as it has been altered. | |
5d00995c | 87 | * |
32826140 HS |
88 | * Unmaps all memory occupied by the carve_desc region from the list entry |
89 | * pointed to by map. | |
852efbf5 SB |
90 | * |
91 | * In case of EFI_CARVE_OVERLAPS_NONRAM it is the callers responsibility | |
32826140 | 92 | * to re-add the already carved out pages to the mapping. |
5d00995c | 93 | */ |
32826140 | 94 | static s64 efi_mem_carve_out(struct efi_mem_list *map, |
5d00995c AG |
95 | struct efi_mem_desc *carve_desc, |
96 | bool overlap_only_ram) | |
97 | { | |
98 | struct efi_mem_list *newmap; | |
99 | struct efi_mem_desc *map_desc = &map->desc; | |
100 | uint64_t map_start = map_desc->physical_start; | |
101 | uint64_t map_end = map_start + (map_desc->num_pages << EFI_PAGE_SHIFT); | |
102 | uint64_t carve_start = carve_desc->physical_start; | |
103 | uint64_t carve_end = carve_start + | |
104 | (carve_desc->num_pages << EFI_PAGE_SHIFT); | |
105 | ||
106 | /* check whether we're overlapping */ | |
107 | if ((carve_end <= map_start) || (carve_start >= map_end)) | |
74c16acc | 108 | return EFI_CARVE_NO_OVERLAP; |
5d00995c AG |
109 | |
110 | /* We're overlapping with non-RAM, warn the caller if desired */ | |
111 | if (overlap_only_ram && (map_desc->type != EFI_CONVENTIONAL_MEMORY)) | |
74c16acc | 112 | return EFI_CARVE_OVERLAPS_NONRAM; |
5d00995c AG |
113 | |
114 | /* Sanitize carve_start and carve_end to lie within our bounds */ | |
115 | carve_start = max(carve_start, map_start); | |
116 | carve_end = min(carve_end, map_end); | |
117 | ||
118 | /* Carving at the beginning of our map? Just move it! */ | |
119 | if (carve_start == map_start) { | |
120 | if (map_end == carve_end) { | |
121 | /* Full overlap, just remove map */ | |
122 | list_del(&map->link); | |
511d0b97 SB |
123 | free(map); |
124 | } else { | |
125 | map->desc.physical_start = carve_end; | |
126 | map->desc.num_pages = (map_end - carve_end) | |
127 | >> EFI_PAGE_SHIFT; | |
5d00995c AG |
128 | } |
129 | ||
74c16acc | 130 | return (carve_end - carve_start) >> EFI_PAGE_SHIFT; |
5d00995c AG |
131 | } |
132 | ||
133 | /* | |
134 | * Overlapping maps, just split the list map at carve_start, | |
135 | * it will get moved or removed in the next iteration. | |
136 | * | |
137 | * [ map_desc |__carve_start__| newmap ] | |
138 | */ | |
139 | ||
140 | /* Create a new map from [ carve_start ... map_end ] */ | |
141 | newmap = calloc(1, sizeof(*newmap)); | |
142 | newmap->desc = map->desc; | |
143 | newmap->desc.physical_start = carve_start; | |
144 | newmap->desc.num_pages = (map_end - carve_start) >> EFI_PAGE_SHIFT; | |
b6a95172 SB |
145 | /* Insert before current entry (descending address order) */ |
146 | list_add_tail(&newmap->link, &map->link); | |
5d00995c AG |
147 | |
148 | /* Shrink the map to [ map_start ... carve_start ] */ | |
149 | map_desc->num_pages = (carve_start - map_start) >> EFI_PAGE_SHIFT; | |
150 | ||
74c16acc | 151 | return EFI_CARVE_LOOP_AGAIN; |
5d00995c AG |
152 | } |
153 | ||
154 | uint64_t efi_add_memory_map(uint64_t start, uint64_t pages, int memory_type, | |
155 | bool overlap_only_ram) | |
156 | { | |
157 | struct list_head *lhandle; | |
158 | struct efi_mem_list *newlist; | |
74c16acc AG |
159 | bool carve_again; |
160 | uint64_t carved_pages = 0; | |
5d00995c | 161 | |
c933ed94 AF |
162 | debug("%s: 0x%" PRIx64 " 0x%" PRIx64 " %d %s\n", __func__, |
163 | start, pages, memory_type, overlap_only_ram ? "yes" : "no"); | |
164 | ||
1fcb7ea2 HS |
165 | if (memory_type >= EFI_MAX_MEMORY_TYPE) |
166 | return EFI_INVALID_PARAMETER; | |
167 | ||
5d00995c AG |
168 | if (!pages) |
169 | return start; | |
170 | ||
1fcb7ea2 | 171 | ++efi_memory_map_key; |
5d00995c AG |
172 | newlist = calloc(1, sizeof(*newlist)); |
173 | newlist->desc.type = memory_type; | |
174 | newlist->desc.physical_start = start; | |
175 | newlist->desc.virtual_start = start; | |
176 | newlist->desc.num_pages = pages; | |
177 | ||
178 | switch (memory_type) { | |
179 | case EFI_RUNTIME_SERVICES_CODE: | |
180 | case EFI_RUNTIME_SERVICES_DATA: | |
181 | newlist->desc.attribute = (1 << EFI_MEMORY_WB_SHIFT) | | |
182 | (1ULL << EFI_MEMORY_RUNTIME_SHIFT); | |
183 | break; | |
184 | case EFI_MMAP_IO: | |
185 | newlist->desc.attribute = 1ULL << EFI_MEMORY_RUNTIME_SHIFT; | |
186 | break; | |
187 | default: | |
188 | newlist->desc.attribute = 1 << EFI_MEMORY_WB_SHIFT; | |
189 | break; | |
190 | } | |
191 | ||
192 | /* Add our new map */ | |
193 | do { | |
74c16acc | 194 | carve_again = false; |
5d00995c AG |
195 | list_for_each(lhandle, &efi_mem) { |
196 | struct efi_mem_list *lmem; | |
32826140 | 197 | s64 r; |
5d00995c AG |
198 | |
199 | lmem = list_entry(lhandle, struct efi_mem_list, link); | |
200 | r = efi_mem_carve_out(lmem, &newlist->desc, | |
201 | overlap_only_ram); | |
74c16acc AG |
202 | switch (r) { |
203 | case EFI_CARVE_OVERLAPS_NONRAM: | |
204 | /* | |
205 | * The user requested to only have RAM overlaps, | |
206 | * but we hit a non-RAM region. Error out. | |
207 | */ | |
5d00995c | 208 | return 0; |
74c16acc AG |
209 | case EFI_CARVE_NO_OVERLAP: |
210 | /* Just ignore this list entry */ | |
211 | break; | |
212 | case EFI_CARVE_LOOP_AGAIN: | |
213 | /* | |
214 | * We split an entry, but need to loop through | |
215 | * the list again to actually carve it. | |
216 | */ | |
217 | carve_again = true; | |
218 | break; | |
219 | default: | |
220 | /* We carved a number of pages */ | |
221 | carved_pages += r; | |
222 | carve_again = true; | |
223 | break; | |
224 | } | |
225 | ||
226 | if (carve_again) { | |
227 | /* The list changed, we need to start over */ | |
5d00995c AG |
228 | break; |
229 | } | |
230 | } | |
74c16acc AG |
231 | } while (carve_again); |
232 | ||
233 | if (overlap_only_ram && (carved_pages != pages)) { | |
234 | /* | |
235 | * The payload wanted to have RAM overlaps, but we overlapped | |
236 | * with an unallocated region. Error out. | |
237 | */ | |
238 | return 0; | |
239 | } | |
5d00995c AG |
240 | |
241 | /* Add our new map */ | |
242 | list_add_tail(&newlist->link, &efi_mem); | |
243 | ||
38ce65e1 AG |
244 | /* And make sure memory is listed in descending order */ |
245 | efi_mem_sort(); | |
246 | ||
5d00995c AG |
247 | return start; |
248 | } | |
249 | ||
250 | static uint64_t efi_find_free_memory(uint64_t len, uint64_t max_addr) | |
251 | { | |
252 | struct list_head *lhandle; | |
253 | ||
254 | list_for_each(lhandle, &efi_mem) { | |
255 | struct efi_mem_list *lmem = list_entry(lhandle, | |
256 | struct efi_mem_list, link); | |
257 | struct efi_mem_desc *desc = &lmem->desc; | |
258 | uint64_t desc_len = desc->num_pages << EFI_PAGE_SHIFT; | |
259 | uint64_t desc_end = desc->physical_start + desc_len; | |
260 | uint64_t curmax = min(max_addr, desc_end); | |
261 | uint64_t ret = curmax - len; | |
262 | ||
263 | /* We only take memory from free RAM */ | |
264 | if (desc->type != EFI_CONVENTIONAL_MEMORY) | |
265 | continue; | |
266 | ||
267 | /* Out of bounds for max_addr */ | |
268 | if ((ret + len) > max_addr) | |
269 | continue; | |
270 | ||
271 | /* Out of bounds for upper map limit */ | |
272 | if ((ret + len) > desc_end) | |
273 | continue; | |
274 | ||
275 | /* Out of bounds for lower map limit */ | |
276 | if (ret < desc->physical_start) | |
277 | continue; | |
278 | ||
279 | /* Return the highest address in this map within bounds */ | |
280 | return ret; | |
281 | } | |
282 | ||
283 | return 0; | |
284 | } | |
285 | ||
474a6f5a HS |
286 | /* |
287 | * Allocate memory pages. | |
288 | * | |
289 | * @type type of allocation to be performed | |
290 | * @memory_type usage type of the allocated memory | |
291 | * @pages number of pages to be allocated | |
292 | * @memory allocated memory | |
293 | * @return status code | |
294 | */ | |
5d00995c | 295 | efi_status_t efi_allocate_pages(int type, int memory_type, |
f5a2a938 | 296 | efi_uintn_t pages, uint64_t *memory) |
5d00995c AG |
297 | { |
298 | u64 len = pages << EFI_PAGE_SHIFT; | |
299 | efi_status_t r = EFI_SUCCESS; | |
300 | uint64_t addr; | |
301 | ||
4d5e071e HS |
302 | if (!memory) |
303 | return EFI_INVALID_PARAMETER; | |
304 | ||
5d00995c | 305 | switch (type) { |
7c92fd69 | 306 | case EFI_ALLOCATE_ANY_PAGES: |
5d00995c | 307 | /* Any page */ |
ccfc78b8 | 308 | addr = efi_find_free_memory(len, gd->start_addr_sp); |
5d00995c AG |
309 | if (!addr) { |
310 | r = EFI_NOT_FOUND; | |
311 | break; | |
312 | } | |
313 | break; | |
7c92fd69 | 314 | case EFI_ALLOCATE_MAX_ADDRESS: |
5d00995c AG |
315 | /* Max address */ |
316 | addr = efi_find_free_memory(len, *memory); | |
317 | if (!addr) { | |
318 | r = EFI_NOT_FOUND; | |
319 | break; | |
320 | } | |
321 | break; | |
7c92fd69 | 322 | case EFI_ALLOCATE_ADDRESS: |
5d00995c AG |
323 | /* Exact address, reserve it. The addr is already in *memory. */ |
324 | addr = *memory; | |
325 | break; | |
326 | default: | |
327 | /* UEFI doesn't specify other allocation types */ | |
328 | r = EFI_INVALID_PARAMETER; | |
329 | break; | |
330 | } | |
331 | ||
332 | if (r == EFI_SUCCESS) { | |
333 | uint64_t ret; | |
334 | ||
335 | /* Reserve that map in our memory maps */ | |
336 | ret = efi_add_memory_map(addr, pages, memory_type, true); | |
337 | if (ret == addr) { | |
282a06cb | 338 | *memory = (uintptr_t)map_sysmem(addr, len); |
5d00995c AG |
339 | } else { |
340 | /* Map would overlap, bail out */ | |
341 | r = EFI_OUT_OF_RESOURCES; | |
342 | } | |
343 | } | |
344 | ||
345 | return r; | |
346 | } | |
347 | ||
348 | void *efi_alloc(uint64_t len, int memory_type) | |
349 | { | |
350 | uint64_t ret = 0; | |
351 | uint64_t pages = (len + EFI_PAGE_MASK) >> EFI_PAGE_SHIFT; | |
352 | efi_status_t r; | |
353 | ||
e09159c8 HS |
354 | r = efi_allocate_pages(EFI_ALLOCATE_ANY_PAGES, memory_type, pages, |
355 | &ret); | |
5d00995c AG |
356 | if (r == EFI_SUCCESS) |
357 | return (void*)(uintptr_t)ret; | |
358 | ||
359 | return NULL; | |
360 | } | |
361 | ||
474a6f5a HS |
362 | /* |
363 | * Free memory pages. | |
364 | * | |
365 | * @memory start of the memory area to be freed | |
366 | * @pages number of pages to be freed | |
367 | * @return status code | |
368 | */ | |
f5a2a938 | 369 | efi_status_t efi_free_pages(uint64_t memory, efi_uintn_t pages) |
5d00995c | 370 | { |
b61d857b | 371 | uint64_t r = 0; |
282a06cb | 372 | uint64_t addr = map_to_sysmem((void *)(uintptr_t)memory); |
b61d857b | 373 | |
282a06cb | 374 | r = efi_add_memory_map(addr, pages, EFI_CONVENTIONAL_MEMORY, false); |
b61d857b SB |
375 | /* Merging of adjacent free regions is missing */ |
376 | ||
282a06cb | 377 | if (r == addr) |
b61d857b SB |
378 | return EFI_SUCCESS; |
379 | ||
380 | return EFI_NOT_FOUND; | |
5d00995c AG |
381 | } |
382 | ||
474a6f5a HS |
383 | /* |
384 | * Allocate memory from pool. | |
385 | * | |
386 | * @pool_type type of the pool from which memory is to be allocated | |
387 | * @size number of bytes to be allocated | |
388 | * @buffer allocated memory | |
389 | * @return status code | |
390 | */ | |
391 | efi_status_t efi_allocate_pool(int pool_type, efi_uintn_t size, void **buffer) | |
ead1274b SB |
392 | { |
393 | efi_status_t r; | |
282a06cb | 394 | struct efi_pool_allocation *alloc; |
946160f3 RC |
395 | u64 num_pages = (size + sizeof(struct efi_pool_allocation) + |
396 | EFI_PAGE_MASK) >> EFI_PAGE_SHIFT; | |
42417bc8 | 397 | |
4d5e071e HS |
398 | if (!buffer) |
399 | return EFI_INVALID_PARAMETER; | |
400 | ||
42417bc8 SB |
401 | if (size == 0) { |
402 | *buffer = NULL; | |
403 | return EFI_SUCCESS; | |
404 | } | |
ead1274b | 405 | |
e09159c8 | 406 | r = efi_allocate_pages(EFI_ALLOCATE_ANY_PAGES, pool_type, num_pages, |
282a06cb | 407 | (uint64_t *)&alloc); |
42417bc8 SB |
408 | |
409 | if (r == EFI_SUCCESS) { | |
42417bc8 SB |
410 | alloc->num_pages = num_pages; |
411 | *buffer = alloc->data; | |
412 | } | |
413 | ||
414 | return r; | |
415 | } | |
416 | ||
474a6f5a HS |
417 | /* |
418 | * Free memory from pool. | |
419 | * | |
420 | * @buffer start of memory to be freed | |
421 | * @return status code | |
422 | */ | |
42417bc8 SB |
423 | efi_status_t efi_free_pool(void *buffer) |
424 | { | |
425 | efi_status_t r; | |
426 | struct efi_pool_allocation *alloc; | |
427 | ||
71275a3e HS |
428 | if (buffer == NULL) |
429 | return EFI_INVALID_PARAMETER; | |
430 | ||
42417bc8 SB |
431 | alloc = container_of(buffer, struct efi_pool_allocation, data); |
432 | /* Sanity check, was the supplied address returned by allocate_pool */ | |
433 | assert(((uintptr_t)alloc & EFI_PAGE_MASK) == 0); | |
434 | ||
435 | r = efi_free_pages((uintptr_t)alloc, alloc->num_pages); | |
ead1274b SB |
436 | |
437 | return r; | |
438 | } | |
439 | ||
474a6f5a HS |
440 | /* |
441 | * Get map describing memory usage. | |
442 | * | |
443 | * @memory_map_size on entry the size, in bytes, of the memory map buffer, | |
444 | * on exit the size of the copied memory map | |
445 | * @memory_map buffer to which the memory map is written | |
446 | * @map_key key for the memory map | |
447 | * @descriptor_size size of an individual memory descriptor | |
448 | * @descriptor_version version number of the memory descriptor structure | |
449 | * @return status code | |
450 | */ | |
f5a2a938 HS |
451 | efi_status_t efi_get_memory_map(efi_uintn_t *memory_map_size, |
452 | struct efi_mem_desc *memory_map, | |
453 | efi_uintn_t *map_key, | |
454 | efi_uintn_t *descriptor_size, | |
455 | uint32_t *descriptor_version) | |
5d00995c | 456 | { |
f5a2a938 | 457 | efi_uintn_t map_size = 0; |
cee752fa | 458 | int map_entries = 0; |
5d00995c | 459 | struct list_head *lhandle; |
f5a2a938 | 460 | efi_uintn_t provided_map_size = *memory_map_size; |
5d00995c | 461 | |
8e835554 HS |
462 | if (!memory_map_size) |
463 | return EFI_INVALID_PARAMETER; | |
464 | ||
5d00995c | 465 | list_for_each(lhandle, &efi_mem) |
cee752fa AG |
466 | map_entries++; |
467 | ||
468 | map_size = map_entries * sizeof(struct efi_mem_desc); | |
5d00995c | 469 | |
a1b24823 RC |
470 | *memory_map_size = map_size; |
471 | ||
0ecba5db HS |
472 | if (provided_map_size < map_size) |
473 | return EFI_BUFFER_TOO_SMALL; | |
474 | ||
8e835554 HS |
475 | if (!memory_map) |
476 | return EFI_INVALID_PARAMETER; | |
477 | ||
5d00995c AG |
478 | if (descriptor_size) |
479 | *descriptor_size = sizeof(struct efi_mem_desc); | |
480 | ||
4c02c11d MYK |
481 | if (descriptor_version) |
482 | *descriptor_version = EFI_MEMORY_DESCRIPTOR_VERSION; | |
483 | ||
5d00995c | 484 | /* Copy list into array */ |
8e835554 HS |
485 | /* Return the list in ascending order */ |
486 | memory_map = &memory_map[map_entries - 1]; | |
487 | list_for_each(lhandle, &efi_mem) { | |
488 | struct efi_mem_list *lmem; | |
5d00995c | 489 | |
8e835554 HS |
490 | lmem = list_entry(lhandle, struct efi_mem_list, link); |
491 | *memory_map = lmem->desc; | |
492 | memory_map--; | |
5d00995c AG |
493 | } |
494 | ||
8e835554 | 495 | if (map_key) |
1fcb7ea2 | 496 | *map_key = efi_memory_map_key; |
c6e3c3e6 | 497 | |
5d00995c AG |
498 | return EFI_SUCCESS; |
499 | } | |
500 | ||
42633745 | 501 | __weak void efi_add_known_memory(void) |
5d00995c | 502 | { |
5d00995c AG |
503 | int i; |
504 | ||
505 | /* Add RAM */ | |
506 | for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++) { | |
507 | u64 ram_start = gd->bd->bi_dram[i].start; | |
508 | u64 ram_size = gd->bd->bi_dram[i].size; | |
509 | u64 start = (ram_start + EFI_PAGE_MASK) & ~EFI_PAGE_MASK; | |
510 | u64 pages = (ram_size + EFI_PAGE_MASK) >> EFI_PAGE_SHIFT; | |
511 | ||
512 | efi_add_memory_map(start, pages, EFI_CONVENTIONAL_MEMORY, | |
513 | false); | |
514 | } | |
42633745 YS |
515 | } |
516 | ||
69259b83 SG |
517 | /* Add memory regions for U-Boot's memory and for the runtime services code */ |
518 | static void add_u_boot_and_runtime(void) | |
42633745 YS |
519 | { |
520 | unsigned long runtime_start, runtime_end, runtime_pages; | |
521 | unsigned long uboot_start, uboot_pages; | |
522 | unsigned long uboot_stack_size = 16 * 1024 * 1024; | |
523 | ||
5d00995c AG |
524 | /* Add U-Boot */ |
525 | uboot_start = (gd->start_addr_sp - uboot_stack_size) & ~EFI_PAGE_MASK; | |
526 | uboot_pages = (gd->ram_top - uboot_start) >> EFI_PAGE_SHIFT; | |
527 | efi_add_memory_map(uboot_start, uboot_pages, EFI_LOADER_DATA, false); | |
528 | ||
529 | /* Add Runtime Services */ | |
530 | runtime_start = (ulong)&__efi_runtime_start & ~EFI_PAGE_MASK; | |
531 | runtime_end = (ulong)&__efi_runtime_stop; | |
532 | runtime_end = (runtime_end + EFI_PAGE_MASK) & ~EFI_PAGE_MASK; | |
533 | runtime_pages = (runtime_end - runtime_start) >> EFI_PAGE_SHIFT; | |
534 | efi_add_memory_map(runtime_start, runtime_pages, | |
535 | EFI_RUNTIME_SERVICES_CODE, false); | |
69259b83 SG |
536 | } |
537 | ||
538 | int efi_memory_init(void) | |
539 | { | |
540 | efi_add_known_memory(); | |
541 | ||
542 | if (!IS_ENABLED(CONFIG_SANDBOX)) | |
543 | add_u_boot_and_runtime(); | |
5d00995c | 544 | |
51735ae0 AG |
545 | #ifdef CONFIG_EFI_LOADER_BOUNCE_BUFFER |
546 | /* Request a 32bit 64MB bounce buffer region */ | |
547 | uint64_t efi_bounce_buffer_addr = 0xffffffff; | |
548 | ||
e09159c8 | 549 | if (efi_allocate_pages(EFI_ALLOCATE_MAX_ADDRESS, EFI_LOADER_DATA, |
51735ae0 AG |
550 | (64 * 1024 * 1024) >> EFI_PAGE_SHIFT, |
551 | &efi_bounce_buffer_addr) != EFI_SUCCESS) | |
552 | return -1; | |
553 | ||
554 | efi_bounce_buffer = (void*)(uintptr_t)efi_bounce_buffer_addr; | |
555 | #endif | |
556 | ||
5d00995c AG |
557 | return 0; |
558 | } |