2 * EFI application memory management
4 * Copyright (c) 2016 Alexander Graf
6 * SPDX-License-Identifier: GPL-2.0+
10 #include <efi_loader.h>
12 #include <asm/global_data.h>
13 #include <libfdt_env.h>
14 #include <linux/list_sort.h>
18 DECLARE_GLOBAL_DATA_PTR
;
21 struct list_head link
;
22 struct efi_mem_desc desc
;
25 /* This list contains all memory map items */
28 #ifdef CONFIG_EFI_LOADER_BOUNCE_BUFFER
29 void *efi_bounce_buffer
;
33 * Sorts the memory list from highest address to lowest address
35 * When allocating memory we should always start from the highest
36 * address chunk, so sort the memory list such that the first list
37 * iterator gets the highest address and goes lower from there.
39 static int efi_mem_cmp(void *priv
, struct list_head
*a
, struct list_head
*b
)
41 struct efi_mem_list
*mema
= list_entry(a
, struct efi_mem_list
, link
);
42 struct efi_mem_list
*memb
= list_entry(b
, struct efi_mem_list
, link
);
44 if (mema
->desc
.physical_start
== memb
->desc
.physical_start
)
46 else if (mema
->desc
.physical_start
< memb
->desc
.physical_start
)
52 static void efi_mem_sort(void)
54 list_sort(NULL
, &efi_mem
, efi_mem_cmp
);
58 * Unmaps all memory occupied by the carve_desc region from the
59 * list entry pointed to by map.
61 * Returns 1 if carving was performed or 0 if the regions don't overlap.
62 * Returns -1 if it would affect non-RAM regions but overlap_only_ram is set.
63 * Carving is only guaranteed to complete when all regions return 0.
65 static int efi_mem_carve_out(struct efi_mem_list
*map
,
66 struct efi_mem_desc
*carve_desc
,
67 bool overlap_only_ram
)
69 struct efi_mem_list
*newmap
;
70 struct efi_mem_desc
*map_desc
= &map
->desc
;
71 uint64_t map_start
= map_desc
->physical_start
;
72 uint64_t map_end
= map_start
+ (map_desc
->num_pages
<< EFI_PAGE_SHIFT
);
73 uint64_t carve_start
= carve_desc
->physical_start
;
74 uint64_t carve_end
= carve_start
+
75 (carve_desc
->num_pages
<< EFI_PAGE_SHIFT
);
77 /* check whether we're overlapping */
78 if ((carve_end
<= map_start
) || (carve_start
>= map_end
))
81 /* We're overlapping with non-RAM, warn the caller if desired */
82 if (overlap_only_ram
&& (map_desc
->type
!= EFI_CONVENTIONAL_MEMORY
))
85 /* Sanitize carve_start and carve_end to lie within our bounds */
86 carve_start
= max(carve_start
, map_start
);
87 carve_end
= min(carve_end
, map_end
);
89 /* Carving at the beginning of our map? Just move it! */
90 if (carve_start
== map_start
) {
91 if (map_end
== carve_end
) {
92 /* Full overlap, just remove map */
96 map_desc
->physical_start
= carve_end
;
97 map_desc
->num_pages
= (map_end
- carve_end
) >> EFI_PAGE_SHIFT
;
102 * Overlapping maps, just split the list map at carve_start,
103 * it will get moved or removed in the next iteration.
105 * [ map_desc |__carve_start__| newmap ]
108 /* Create a new map from [ carve_start ... map_end ] */
109 newmap
= calloc(1, sizeof(*newmap
));
110 newmap
->desc
= map
->desc
;
111 newmap
->desc
.physical_start
= carve_start
;
112 newmap
->desc
.num_pages
= (map_end
- carve_start
) >> EFI_PAGE_SHIFT
;
113 list_add_tail(&newmap
->link
, &efi_mem
);
115 /* Shrink the map to [ map_start ... carve_start ] */
116 map_desc
->num_pages
= (carve_start
- map_start
) >> EFI_PAGE_SHIFT
;
121 uint64_t efi_add_memory_map(uint64_t start
, uint64_t pages
, int memory_type
,
122 bool overlap_only_ram
)
124 struct list_head
*lhandle
;
125 struct efi_mem_list
*newlist
;
131 newlist
= calloc(1, sizeof(*newlist
));
132 newlist
->desc
.type
= memory_type
;
133 newlist
->desc
.physical_start
= start
;
134 newlist
->desc
.virtual_start
= start
;
135 newlist
->desc
.num_pages
= pages
;
137 switch (memory_type
) {
138 case EFI_RUNTIME_SERVICES_CODE
:
139 case EFI_RUNTIME_SERVICES_DATA
:
140 newlist
->desc
.attribute
= (1 << EFI_MEMORY_WB_SHIFT
) |
141 (1ULL << EFI_MEMORY_RUNTIME_SHIFT
);
144 newlist
->desc
.attribute
= 1ULL << EFI_MEMORY_RUNTIME_SHIFT
;
147 newlist
->desc
.attribute
= 1 << EFI_MEMORY_WB_SHIFT
;
151 /* Add our new map */
154 list_for_each(lhandle
, &efi_mem
) {
155 struct efi_mem_list
*lmem
;
158 lmem
= list_entry(lhandle
, struct efi_mem_list
, link
);
159 r
= efi_mem_carve_out(lmem
, &newlist
->desc
,
168 } while (do_carving
);
170 /* Add our new map */
171 list_add_tail(&newlist
->link
, &efi_mem
);
173 /* And make sure memory is listed in descending order */
179 static uint64_t efi_find_free_memory(uint64_t len
, uint64_t max_addr
)
181 struct list_head
*lhandle
;
183 list_for_each(lhandle
, &efi_mem
) {
184 struct efi_mem_list
*lmem
= list_entry(lhandle
,
185 struct efi_mem_list
, link
);
186 struct efi_mem_desc
*desc
= &lmem
->desc
;
187 uint64_t desc_len
= desc
->num_pages
<< EFI_PAGE_SHIFT
;
188 uint64_t desc_end
= desc
->physical_start
+ desc_len
;
189 uint64_t curmax
= min(max_addr
, desc_end
);
190 uint64_t ret
= curmax
- len
;
192 /* We only take memory from free RAM */
193 if (desc
->type
!= EFI_CONVENTIONAL_MEMORY
)
196 /* Out of bounds for max_addr */
197 if ((ret
+ len
) > max_addr
)
200 /* Out of bounds for upper map limit */
201 if ((ret
+ len
) > desc_end
)
204 /* Out of bounds for lower map limit */
205 if (ret
< desc
->physical_start
)
208 /* Return the highest address in this map within bounds */
215 efi_status_t
efi_allocate_pages(int type
, int memory_type
,
216 unsigned long pages
, uint64_t *memory
)
218 u64 len
= pages
<< EFI_PAGE_SHIFT
;
219 efi_status_t r
= EFI_SUCCESS
;
225 addr
= efi_find_free_memory(len
, gd
->start_addr_sp
);
233 addr
= efi_find_free_memory(len
, *memory
);
240 /* Exact address, reserve it. The addr is already in *memory. */
244 /* UEFI doesn't specify other allocation types */
245 r
= EFI_INVALID_PARAMETER
;
249 if (r
== EFI_SUCCESS
) {
252 /* Reserve that map in our memory maps */
253 ret
= efi_add_memory_map(addr
, pages
, memory_type
, true);
257 /* Map would overlap, bail out */
258 r
= EFI_OUT_OF_RESOURCES
;
265 void *efi_alloc(uint64_t len
, int memory_type
)
268 uint64_t pages
= (len
+ EFI_PAGE_MASK
) >> EFI_PAGE_SHIFT
;
271 r
= efi_allocate_pages(0, memory_type
, pages
, &ret
);
272 if (r
== EFI_SUCCESS
)
273 return (void*)(uintptr_t)ret
;
278 efi_status_t
efi_free_pages(uint64_t memory
, unsigned long pages
)
280 /* We don't free, let's cross our fingers we have plenty RAM */
284 efi_status_t
efi_get_memory_map(unsigned long *memory_map_size
,
285 struct efi_mem_desc
*memory_map
,
286 unsigned long *map_key
,
287 unsigned long *descriptor_size
,
288 uint32_t *descriptor_version
)
292 struct list_head
*lhandle
;
294 list_for_each(lhandle
, &efi_mem
)
297 map_size
= map_entries
* sizeof(struct efi_mem_desc
);
299 *memory_map_size
= map_size
;
302 *descriptor_size
= sizeof(struct efi_mem_desc
);
304 if (*memory_map_size
< map_size
)
305 return EFI_BUFFER_TOO_SMALL
;
307 /* Copy list into array */
309 /* Return the list in ascending order */
310 memory_map
= &memory_map
[map_entries
- 1];
311 list_for_each(lhandle
, &efi_mem
) {
312 struct efi_mem_list
*lmem
;
314 lmem
= list_entry(lhandle
, struct efi_mem_list
, link
);
315 *memory_map
= lmem
->desc
;
323 int efi_memory_init(void)
325 unsigned long runtime_start
, runtime_end
, runtime_pages
;
326 unsigned long uboot_start
, uboot_pages
;
327 unsigned long uboot_stack_size
= 16 * 1024 * 1024;
331 for (i
= 0; i
< CONFIG_NR_DRAM_BANKS
; i
++) {
332 u64 ram_start
= gd
->bd
->bi_dram
[i
].start
;
333 u64 ram_size
= gd
->bd
->bi_dram
[i
].size
;
334 u64 start
= (ram_start
+ EFI_PAGE_MASK
) & ~EFI_PAGE_MASK
;
335 u64 pages
= (ram_size
+ EFI_PAGE_MASK
) >> EFI_PAGE_SHIFT
;
337 efi_add_memory_map(start
, pages
, EFI_CONVENTIONAL_MEMORY
,
342 uboot_start
= (gd
->start_addr_sp
- uboot_stack_size
) & ~EFI_PAGE_MASK
;
343 uboot_pages
= (gd
->ram_top
- uboot_start
) >> EFI_PAGE_SHIFT
;
344 efi_add_memory_map(uboot_start
, uboot_pages
, EFI_LOADER_DATA
, false);
346 /* Add Runtime Services */
347 runtime_start
= (ulong
)&__efi_runtime_start
& ~EFI_PAGE_MASK
;
348 runtime_end
= (ulong
)&__efi_runtime_stop
;
349 runtime_end
= (runtime_end
+ EFI_PAGE_MASK
) & ~EFI_PAGE_MASK
;
350 runtime_pages
= (runtime_end
- runtime_start
) >> EFI_PAGE_SHIFT
;
351 efi_add_memory_map(runtime_start
, runtime_pages
,
352 EFI_RUNTIME_SERVICES_CODE
, false);
354 #ifdef CONFIG_EFI_LOADER_BOUNCE_BUFFER
355 /* Request a 32bit 64MB bounce buffer region */
356 uint64_t efi_bounce_buffer_addr
= 0xffffffff;
358 if (efi_allocate_pages(1, EFI_LOADER_DATA
,
359 (64 * 1024 * 1024) >> EFI_PAGE_SHIFT
,
360 &efi_bounce_buffer_addr
) != EFI_SUCCESS
)
363 efi_bounce_buffer
= (void*)(uintptr_t)efi_bounce_buffer_addr
;