]> Git Repo - u-boot.git/blame_incremental - lib/lmb.c
Merge branch 'master' of https://source.denx.de/u-boot/custodians/u-boot-sh
[u-boot.git] / lib / lmb.c
... / ...
CommitLineData
1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Procedures for maintaining information about logical memory blocks.
4 *
5 * Peter Bergner, IBM Corp. June 2001.
6 * Copyright (C) 2001 Peter Bergner.
7 */
8
9#include <alist.h>
10#include <efi_loader.h>
11#include <event.h>
12#include <image.h>
13#include <mapmem.h>
14#include <lmb.h>
15#include <log.h>
16#include <malloc.h>
17#include <spl.h>
18
19#include <asm/global_data.h>
20#include <asm/sections.h>
21#include <linux/kernel.h>
22#include <linux/sizes.h>
23
24DECLARE_GLOBAL_DATA_PTR;
25
26#define MAP_OP_RESERVE (u8)0x1
27#define MAP_OP_FREE (u8)0x2
28#define MAP_OP_ADD (u8)0x3
29
30/*
31 * The following low level LMB functions must not access the global LMB memory
32 * map since they are also used to manage IOVA memory maps in iommu drivers like
33 * apple_dart.
34 */
35
36static long lmb_addrs_overlap(phys_addr_t base1, phys_size_t size1,
37 phys_addr_t base2, phys_size_t size2)
38{
39 const phys_addr_t base1_end = base1 + size1 - 1;
40 const phys_addr_t base2_end = base2 + size2 - 1;
41
42 return ((base1 <= base2_end) && (base2 <= base1_end));
43}
44
45static long lmb_addrs_adjacent(phys_addr_t base1, phys_size_t size1,
46 phys_addr_t base2, phys_size_t size2)
47{
48 if (base2 == base1 + size1)
49 return 1;
50 else if (base1 == base2 + size2)
51 return -1;
52
53 return 0;
54}
55
56static long lmb_regions_overlap(struct alist *lmb_rgn_lst, unsigned long r1,
57 unsigned long r2)
58{
59 struct lmb_region *rgn = lmb_rgn_lst->data;
60 phys_addr_t base1 = rgn[r1].base;
61 phys_size_t size1 = rgn[r1].size;
62 phys_addr_t base2 = rgn[r2].base;
63 phys_size_t size2 = rgn[r2].size;
64
65 return lmb_addrs_overlap(base1, size1, base2, size2);
66}
67
68static long lmb_regions_adjacent(struct alist *lmb_rgn_lst, unsigned long r1,
69 unsigned long r2)
70{
71 struct lmb_region *rgn = lmb_rgn_lst->data;
72 phys_addr_t base1 = rgn[r1].base;
73 phys_size_t size1 = rgn[r1].size;
74 phys_addr_t base2 = rgn[r2].base;
75 phys_size_t size2 = rgn[r2].size;
76
77 return lmb_addrs_adjacent(base1, size1, base2, size2);
78}
79
80static void lmb_remove_region(struct alist *lmb_rgn_lst, unsigned long r)
81{
82 unsigned long i;
83 struct lmb_region *rgn = lmb_rgn_lst->data;
84
85 for (i = r; i < lmb_rgn_lst->count - 1; i++) {
86 rgn[i].base = rgn[i + 1].base;
87 rgn[i].size = rgn[i + 1].size;
88 rgn[i].flags = rgn[i + 1].flags;
89 }
90 lmb_rgn_lst->count--;
91}
92
93/* Assumption: base addr of region 1 < base addr of region 2 */
94static void lmb_coalesce_regions(struct alist *lmb_rgn_lst, unsigned long r1,
95 unsigned long r2)
96{
97 struct lmb_region *rgn = lmb_rgn_lst->data;
98
99 rgn[r1].size += rgn[r2].size;
100 lmb_remove_region(lmb_rgn_lst, r2);
101}
102
103/*Assumption : base addr of region 1 < base addr of region 2*/
104static void lmb_fix_over_lap_regions(struct alist *lmb_rgn_lst,
105 unsigned long r1, unsigned long r2)
106{
107 struct lmb_region *rgn = lmb_rgn_lst->data;
108
109 phys_addr_t base1 = rgn[r1].base;
110 phys_size_t size1 = rgn[r1].size;
111 phys_addr_t base2 = rgn[r2].base;
112 phys_size_t size2 = rgn[r2].size;
113
114 if (base1 + size1 > base2 + size2) {
115 printf("This will not be a case any time\n");
116 return;
117 }
118 rgn[r1].size = base2 + size2 - base1;
119 lmb_remove_region(lmb_rgn_lst, r2);
120}
121
122static long lmb_resize_regions(struct alist *lmb_rgn_lst,
123 unsigned long idx_start,
124 phys_addr_t base, phys_size_t size)
125{
126 phys_size_t rgnsize;
127 unsigned long rgn_cnt, idx, idx_end;
128 phys_addr_t rgnbase, rgnend;
129 phys_addr_t mergebase, mergeend;
130 struct lmb_region *rgn = lmb_rgn_lst->data;
131
132 rgn_cnt = 0;
133 idx = idx_start;
134 idx_end = idx_start;
135
136 /*
137 * First thing to do is to identify how many regions
138 * the requested region overlaps.
139 * If the flags match, combine all these overlapping
140 * regions into a single region, and remove the merged
141 * regions.
142 */
143 while (idx <= lmb_rgn_lst->count - 1) {
144 rgnbase = rgn[idx].base;
145 rgnsize = rgn[idx].size;
146
147 if (lmb_addrs_overlap(base, size, rgnbase,
148 rgnsize)) {
149 if (rgn[idx].flags != LMB_NONE)
150 return -1;
151 rgn_cnt++;
152 idx_end = idx;
153 }
154 idx++;
155 }
156
157 /* The merged region's base and size */
158 rgnbase = rgn[idx_start].base;
159 mergebase = min(base, rgnbase);
160 rgnend = rgn[idx_end].base + rgn[idx_end].size;
161 mergeend = max(rgnend, (base + size));
162
163 rgn[idx_start].base = mergebase;
164 rgn[idx_start].size = mergeend - mergebase;
165
166 /* Now remove the merged regions */
167 while (--rgn_cnt)
168 lmb_remove_region(lmb_rgn_lst, idx_start + 1);
169
170 return 0;
171}
172
173/**
174 * lmb_add_region_flags() - Add an lmb region to the given list
175 * @lmb_rgn_lst: LMB list to which region is to be added(free/used)
176 * @base: Start address of the region
177 * @size: Size of the region to be added
178 * @flags: Attributes of the LMB region
179 *
180 * Add a region of memory to the list. If the region does not exist, add
181 * it to the list. Depending on the attributes of the region to be added,
182 * the function might resize an already existing region or coalesce two
183 * adjacent regions.
184 *
185 * Return:
186 * * %0 - Added successfully, or it's already added (only if LMB_NONE)
187 * * %-EEXIST - The region is already added, and flags != LMB_NONE
188 * * %-1 - Failure
189 */
190static long lmb_add_region_flags(struct alist *lmb_rgn_lst, phys_addr_t base,
191 phys_size_t size, u32 flags)
192{
193 unsigned long coalesced = 0;
194 long ret, i;
195 struct lmb_region *rgn = lmb_rgn_lst->data;
196
197 if (alist_err(lmb_rgn_lst))
198 return -1;
199
200 /* First try and coalesce this LMB with another. */
201 for (i = 0; i < lmb_rgn_lst->count; i++) {
202 phys_addr_t rgnbase = rgn[i].base;
203 phys_size_t rgnsize = rgn[i].size;
204 u32 rgnflags = rgn[i].flags;
205
206 ret = lmb_addrs_adjacent(base, size, rgnbase, rgnsize);
207 if (ret > 0) {
208 if (flags != rgnflags)
209 break;
210 rgn[i].base -= size;
211 rgn[i].size += size;
212 coalesced++;
213 break;
214 } else if (ret < 0) {
215 if (flags != rgnflags)
216 break;
217 rgn[i].size += size;
218 coalesced++;
219 break;
220 } else if (lmb_addrs_overlap(base, size, rgnbase, rgnsize)) {
221 if (flags != LMB_NONE)
222 return -EEXIST;
223
224 ret = lmb_resize_regions(lmb_rgn_lst, i, base, size);
225 if (ret < 0)
226 return -1;
227
228 coalesced++;
229 break;
230
231 return -1;
232 }
233 }
234
235 if (lmb_rgn_lst->count && i < lmb_rgn_lst->count - 1) {
236 rgn = lmb_rgn_lst->data;
237 if (rgn[i].flags == rgn[i + 1].flags) {
238 if (lmb_regions_adjacent(lmb_rgn_lst, i, i + 1)) {
239 lmb_coalesce_regions(lmb_rgn_lst, i, i + 1);
240 coalesced++;
241 } else if (lmb_regions_overlap(lmb_rgn_lst, i, i + 1)) {
242 /* fix overlapping area */
243 lmb_fix_over_lap_regions(lmb_rgn_lst, i, i + 1);
244 coalesced++;
245 }
246 }
247 }
248
249 if (coalesced)
250 return 0;
251
252 if (alist_full(lmb_rgn_lst) &&
253 !alist_expand_by(lmb_rgn_lst, lmb_rgn_lst->alloc))
254 return -1;
255 rgn = lmb_rgn_lst->data;
256
257 /* Couldn't coalesce the LMB, so add it to the sorted table. */
258 for (i = lmb_rgn_lst->count; i >= 0; i--) {
259 if (i && base < rgn[i - 1].base) {
260 rgn[i] = rgn[i - 1];
261 } else {
262 rgn[i].base = base;
263 rgn[i].size = size;
264 rgn[i].flags = flags;
265 break;
266 }
267 }
268
269 lmb_rgn_lst->count++;
270
271 return 0;
272}
273
274static long _lmb_free(struct alist *lmb_rgn_lst, phys_addr_t base,
275 phys_size_t size)
276{
277 struct lmb_region *rgn;
278 phys_addr_t rgnbegin, rgnend;
279 phys_addr_t end = base + size - 1;
280 int i;
281
282 /* Suppress GCC warnings */
283 rgnbegin = 0;
284 rgnend = 0;
285
286 rgn = lmb_rgn_lst->data;
287 /* Find the region where (base, size) belongs to */
288 for (i = 0; i < lmb_rgn_lst->count; i++) {
289 rgnbegin = rgn[i].base;
290 rgnend = rgnbegin + rgn[i].size - 1;
291
292 if (rgnbegin <= base && end <= rgnend)
293 break;
294 }
295
296 /* Didn't find the region */
297 if (i == lmb_rgn_lst->count)
298 return -1;
299
300 /* Check to see if we are removing entire region */
301 if (rgnbegin == base && rgnend == end) {
302 lmb_remove_region(lmb_rgn_lst, i);
303 return 0;
304 }
305
306 /* Check to see if region is matching at the front */
307 if (rgnbegin == base) {
308 rgn[i].base = end + 1;
309 rgn[i].size -= size;
310 return 0;
311 }
312
313 /* Check to see if the region is matching at the end */
314 if (rgnend == end) {
315 rgn[i].size -= size;
316 return 0;
317 }
318
319 /*
320 * We need to split the entry - adjust the current one to the
321 * beginging of the hole and add the region after hole.
322 */
323 rgn[i].size = base - rgn[i].base;
324 return lmb_add_region_flags(lmb_rgn_lst, end + 1, rgnend - end,
325 rgn[i].flags);
326}
327
328static long lmb_overlaps_region(struct alist *lmb_rgn_lst, phys_addr_t base,
329 phys_size_t size)
330{
331 unsigned long i;
332 struct lmb_region *rgn = lmb_rgn_lst->data;
333
334 for (i = 0; i < lmb_rgn_lst->count; i++) {
335 phys_addr_t rgnbase = rgn[i].base;
336 phys_size_t rgnsize = rgn[i].size;
337
338 if (lmb_addrs_overlap(base, size, rgnbase, rgnsize))
339 break;
340 }
341
342 return (i < lmb_rgn_lst->count) ? i : -1;
343}
344
345/*
346 * IOVA LMB memory maps using lmb pointers instead of the global LMB memory map.
347 */
348
349int io_lmb_setup(struct lmb *io_lmb)
350{
351 int ret;
352
353 ret = alist_init(&io_lmb->available_mem, sizeof(struct lmb_region),
354 (uint)LMB_ALIST_INITIAL_SIZE);
355 if (!ret) {
356 log_debug("Unable to initialise the list for LMB free IOVA\n");
357 return -ENOMEM;
358 }
359
360 ret = alist_init(&io_lmb->used_mem, sizeof(struct lmb_region),
361 (uint)LMB_ALIST_INITIAL_SIZE);
362 if (!ret) {
363 log_debug("Unable to initialise the list for LMB used IOVA\n");
364 return -ENOMEM;
365 }
366
367 io_lmb->test = false;
368
369 return 0;
370}
371
372void io_lmb_teardown(struct lmb *io_lmb)
373{
374 alist_uninit(&io_lmb->available_mem);
375 alist_uninit(&io_lmb->used_mem);
376}
377
378long io_lmb_add(struct lmb *io_lmb, phys_addr_t base, phys_size_t size)
379{
380 return lmb_add_region_flags(&io_lmb->available_mem, base, size, LMB_NONE);
381}
382
383/* derived and simplified from _lmb_alloc_base() */
384phys_addr_t io_lmb_alloc(struct lmb *io_lmb, phys_size_t size, ulong align)
385{
386 long i, rgn;
387 phys_addr_t base = 0;
388 phys_addr_t res_base;
389 struct lmb_region *lmb_used = io_lmb->used_mem.data;
390 struct lmb_region *lmb_memory = io_lmb->available_mem.data;
391
392 for (i = io_lmb->available_mem.count - 1; i >= 0; i--) {
393 phys_addr_t lmbbase = lmb_memory[i].base;
394 phys_size_t lmbsize = lmb_memory[i].size;
395
396 if (lmbsize < size)
397 continue;
398 base = ALIGN_DOWN(lmbbase + lmbsize - size, align);
399
400 while (base && lmbbase <= base) {
401 rgn = lmb_overlaps_region(&io_lmb->used_mem, base, size);
402 if (rgn < 0) {
403 /* This area isn't reserved, take it */
404 if (lmb_add_region_flags(&io_lmb->used_mem, base,
405 size, LMB_NONE) < 0)
406 return 0;
407
408 return base;
409 }
410
411 res_base = lmb_used[rgn].base;
412 if (res_base < size)
413 break;
414 base = ALIGN_DOWN(res_base - size, align);
415 }
416 }
417 return 0;
418}
419
420long io_lmb_free(struct lmb *io_lmb, phys_addr_t base, phys_size_t size)
421{
422 return _lmb_free(&io_lmb->used_mem, base, size);
423}
424
425/*
426 * Low level LMB functions are used to manage IOVA memory maps for the Apple
427 * dart iommu. They must not access the global LMB memory map.
428 * So keep the global LMB variable declaration unreachable from them.
429 */
430
431static struct lmb lmb;
432
433static bool lmb_should_notify(u32 flags)
434{
435 return !lmb.test && !(flags & LMB_NONOTIFY) &&
436 CONFIG_IS_ENABLED(EFI_LOADER);
437}
438
439static int lmb_map_update_notify(phys_addr_t addr, phys_size_t size, u8 op,
440 u32 flags)
441{
442 u64 efi_addr;
443 u64 pages;
444 efi_status_t status;
445
446 if (op != MAP_OP_RESERVE && op != MAP_OP_FREE && op != MAP_OP_ADD) {
447 log_err("Invalid map update op received (%d)\n", op);
448 return -1;
449 }
450
451 if (!lmb_should_notify(flags))
452 return 0;
453
454 efi_addr = (uintptr_t)map_sysmem(addr, 0);
455 pages = efi_size_in_pages(size + (efi_addr & EFI_PAGE_MASK));
456 efi_addr &= ~EFI_PAGE_MASK;
457
458 status = efi_add_memory_map_pg(efi_addr, pages,
459 op == MAP_OP_RESERVE ?
460 EFI_BOOT_SERVICES_DATA :
461 EFI_CONVENTIONAL_MEMORY,
462 false);
463 if (status != EFI_SUCCESS) {
464 log_err("%s: LMB Map notify failure %lu\n", __func__,
465 status & ~EFI_ERROR_MASK);
466 return -1;
467 }
468 unmap_sysmem((void *)(uintptr_t)efi_addr);
469
470 return 0;
471}
472
473static void lmb_print_region_flags(u32 flags)
474{
475 const char * const flag_str[] = { "none", "no-map", "no-overwrite",
476 "no-notify" };
477 unsigned int pflags = flags &
478 (LMB_NOMAP | LMB_NOOVERWRITE | LMB_NONOTIFY);
479
480 if (flags != pflags) {
481 printf("invalid %#x\n", flags);
482 return;
483 }
484
485 do {
486 int bitpos = pflags ? fls(pflags) - 1 : 0;
487
488 printf("%s", flag_str[bitpos]);
489 pflags &= ~(1u << bitpos);
490 puts(pflags ? ", " : "\n");
491 } while (pflags);
492}
493
494static void lmb_dump_region(struct alist *lmb_rgn_lst, char *name)
495{
496 struct lmb_region *rgn = lmb_rgn_lst->data;
497 unsigned long long base, size, end;
498 u32 flags;
499 int i;
500
501 printf(" %s.count = %#x\n", name, lmb_rgn_lst->count);
502
503 for (i = 0; i < lmb_rgn_lst->count; i++) {
504 base = rgn[i].base;
505 size = rgn[i].size;
506 end = base + size - 1;
507 flags = rgn[i].flags;
508
509 printf(" %s[%d]\t[%#llx-%#llx], %#llx bytes, flags: ",
510 name, i, base, end, size);
511 lmb_print_region_flags(flags);
512 }
513}
514
515void lmb_dump_all_force(void)
516{
517 printf("lmb_dump_all:\n");
518 lmb_dump_region(&lmb.available_mem, "memory");
519 lmb_dump_region(&lmb.used_mem, "reserved");
520}
521
522void lmb_dump_all(void)
523{
524#ifdef DEBUG
525 lmb_dump_all_force();
526#endif
527}
528
529static void lmb_reserve_uboot_region(void)
530{
531 int bank;
532 ulong end, bank_end;
533 phys_addr_t rsv_start;
534
535 rsv_start = gd->start_addr_sp - CONFIG_STACK_SIZE;
536 end = gd->ram_top;
537
538 /*
539 * Reserve memory from aligned address below the bottom of U-Boot stack
540 * until end of RAM area to prevent LMB from overwriting that memory.
541 */
542 debug("## Current stack ends at 0x%08lx ", (ulong)rsv_start);
543
544 for (bank = 0; bank < CONFIG_NR_DRAM_BANKS; bank++) {
545 if (!gd->bd->bi_dram[bank].size ||
546 rsv_start < gd->bd->bi_dram[bank].start)
547 continue;
548 /* Watch out for RAM at end of address space! */
549 bank_end = gd->bd->bi_dram[bank].start +
550 gd->bd->bi_dram[bank].size - 1;
551 if (rsv_start > bank_end)
552 continue;
553 if (bank_end > end)
554 bank_end = end - 1;
555
556 lmb_reserve(rsv_start, bank_end - rsv_start + 1, LMB_NOOVERWRITE);
557
558 if (gd->flags & GD_FLG_SKIP_RELOC)
559 lmb_reserve((phys_addr_t)(uintptr_t)_start,
560 gd->mon_len, LMB_NOOVERWRITE);
561
562 break;
563 }
564}
565
566static void lmb_reserve_common(void *fdt_blob)
567{
568 lmb_reserve_uboot_region();
569
570 if (CONFIG_IS_ENABLED(OF_LIBFDT) && fdt_blob)
571 boot_fdt_add_mem_rsv_regions(fdt_blob);
572}
573
574static __maybe_unused void lmb_reserve_common_spl(void)
575{
576 phys_addr_t rsv_start;
577 phys_size_t rsv_size;
578
579 /*
580 * Assume a SPL stack of 16KB. This must be
581 * more than enough for the SPL stage.
582 */
583 if (IS_ENABLED(CONFIG_SPL_STACK_R_ADDR)) {
584 rsv_start = gd->start_addr_sp - 16384;
585 rsv_size = 16384;
586 lmb_reserve(rsv_start, rsv_size, LMB_NOOVERWRITE);
587 }
588
589 if (IS_ENABLED(CONFIG_SPL_SEPARATE_BSS)) {
590 /* Reserve the bss region */
591 rsv_start = (phys_addr_t)(uintptr_t)__bss_start;
592 rsv_size = (phys_addr_t)(uintptr_t)__bss_end -
593 (phys_addr_t)(uintptr_t)__bss_start;
594 lmb_reserve(rsv_start, rsv_size, LMB_NOOVERWRITE);
595 }
596}
597
598void lmb_add_memory(void)
599{
600 int i;
601 phys_addr_t bank_end;
602 phys_size_t size;
603 u64 ram_top = gd->ram_top;
604 struct bd_info *bd = gd->bd;
605
606 if (CONFIG_IS_ENABLED(LMB_ARCH_MEM_MAP))
607 return lmb_arch_add_memory();
608
609 /* Assume a 4GB ram_top if not defined */
610 if (!ram_top)
611 ram_top = 0x100000000ULL;
612
613 for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++) {
614 size = bd->bi_dram[i].size;
615 bank_end = bd->bi_dram[i].start + size;
616
617 if (size) {
618 lmb_add(bd->bi_dram[i].start, size);
619
620 /*
621 * Reserve memory above ram_top as
622 * no-overwrite so that it cannot be
623 * allocated
624 */
625 if (bd->bi_dram[i].start >= ram_top)
626 lmb_reserve(bd->bi_dram[i].start, size,
627 LMB_NOOVERWRITE);
628 else if (bank_end > ram_top)
629 lmb_reserve(ram_top, bank_end - ram_top,
630 LMB_NOOVERWRITE);
631 }
632 }
633}
634
635/* This routine may be called with relocation disabled. */
636long lmb_add(phys_addr_t base, phys_size_t size)
637{
638 long ret;
639 struct alist *lmb_rgn_lst = &lmb.available_mem;
640
641 ret = lmb_add_region_flags(lmb_rgn_lst, base, size, LMB_NONE);
642 if (ret)
643 return ret;
644
645 return lmb_map_update_notify(base, size, MAP_OP_ADD, LMB_NONE);
646}
647
648long lmb_free_flags(phys_addr_t base, phys_size_t size,
649 uint flags)
650{
651 long ret;
652
653 ret = _lmb_free(&lmb.used_mem, base, size);
654 if (ret < 0)
655 return ret;
656
657 return lmb_map_update_notify(base, size, MAP_OP_FREE, flags);
658}
659
660long lmb_free(phys_addr_t base, phys_size_t size)
661{
662 return lmb_free_flags(base, size, LMB_NONE);
663}
664
665long lmb_reserve(phys_addr_t base, phys_size_t size, u32 flags)
666{
667 long ret = 0;
668 struct alist *lmb_rgn_lst = &lmb.used_mem;
669
670 ret = lmb_add_region_flags(lmb_rgn_lst, base, size, flags);
671 if (ret)
672 return ret;
673
674 return lmb_map_update_notify(base, size, MAP_OP_RESERVE, flags);
675}
676
677static phys_addr_t _lmb_alloc_base(phys_size_t size, ulong align,
678 phys_addr_t max_addr, u32 flags)
679{
680 int ret;
681 long i, rgn;
682 phys_addr_t base = 0;
683 phys_addr_t res_base;
684 struct lmb_region *lmb_used = lmb.used_mem.data;
685 struct lmb_region *lmb_memory = lmb.available_mem.data;
686
687 for (i = lmb.available_mem.count - 1; i >= 0; i--) {
688 phys_addr_t lmbbase = lmb_memory[i].base;
689 phys_size_t lmbsize = lmb_memory[i].size;
690
691 if (lmbsize < size)
692 continue;
693
694 if (max_addr == LMB_ALLOC_ANYWHERE) {
695 base = ALIGN_DOWN(lmbbase + lmbsize - size, align);
696 } else if (lmbbase < max_addr) {
697 base = lmbbase + lmbsize;
698 if (base < lmbbase)
699 base = -1;
700 base = min(base, max_addr);
701 base = ALIGN_DOWN(base - size, align);
702 } else {
703 continue;
704 }
705
706 while (base && lmbbase <= base) {
707 rgn = lmb_overlaps_region(&lmb.used_mem, base, size);
708 if (rgn < 0) {
709 /* This area isn't reserved, take it */
710 if (lmb_add_region_flags(&lmb.used_mem, base,
711 size, flags))
712 return 0;
713
714 ret = lmb_map_update_notify(base, size,
715 MAP_OP_RESERVE,
716 flags);
717 if (ret)
718 return ret;
719
720 return base;
721 }
722
723 res_base = lmb_used[rgn].base;
724 if (res_base < size)
725 break;
726 base = ALIGN_DOWN(res_base - size, align);
727 }
728 }
729 return 0;
730}
731
732phys_addr_t lmb_alloc(phys_size_t size, ulong align)
733{
734 return lmb_alloc_base(size, align, LMB_ALLOC_ANYWHERE, LMB_NONE);
735}
736
737phys_addr_t lmb_alloc_base(phys_size_t size, ulong align, phys_addr_t max_addr,
738 uint flags)
739{
740 phys_addr_t alloc;
741
742 alloc = _lmb_alloc_base(size, align, max_addr, flags);
743
744 if (alloc == 0)
745 printf("ERROR: Failed to allocate 0x%lx bytes below 0x%lx.\n",
746 (ulong)size, (ulong)max_addr);
747
748 return alloc;
749}
750
751phys_addr_t lmb_alloc_addr(phys_addr_t base, phys_size_t size, u32 flags)
752{
753 long rgn;
754 struct lmb_region *lmb_memory = lmb.available_mem.data;
755
756 /* Check if the requested address is in one of the memory regions */
757 rgn = lmb_overlaps_region(&lmb.available_mem, base, size);
758 if (rgn >= 0) {
759 /*
760 * Check if the requested end address is in the same memory
761 * region we found.
762 */
763 if (lmb_addrs_overlap(lmb_memory[rgn].base,
764 lmb_memory[rgn].size,
765 base + size - 1, 1)) {
766 /* ok, reserve the memory */
767 if (!lmb_reserve(base, size, flags))
768 return base;
769 }
770 }
771
772 return 0;
773}
774
775/* Return number of bytes from a given address that are free */
776phys_size_t lmb_get_free_size(phys_addr_t addr)
777{
778 int i;
779 long rgn;
780 struct lmb_region *lmb_used = lmb.used_mem.data;
781 struct lmb_region *lmb_memory = lmb.available_mem.data;
782
783 /* check if the requested address is in the memory regions */
784 rgn = lmb_overlaps_region(&lmb.available_mem, addr, 1);
785 if (rgn >= 0) {
786 for (i = 0; i < lmb.used_mem.count; i++) {
787 if (addr < lmb_used[i].base) {
788 /* first reserved range > requested address */
789 return lmb_used[i].base - addr;
790 }
791 if (lmb_used[i].base +
792 lmb_used[i].size > addr) {
793 /* requested addr is in this reserved range */
794 return 0;
795 }
796 }
797 /* if we come here: no reserved ranges above requested addr */
798 return lmb_memory[lmb.available_mem.count - 1].base +
799 lmb_memory[lmb.available_mem.count - 1].size - addr;
800 }
801 return 0;
802}
803
804int lmb_is_reserved_flags(phys_addr_t addr, int flags)
805{
806 int i;
807 struct lmb_region *lmb_used = lmb.used_mem.data;
808
809 for (i = 0; i < lmb.used_mem.count; i++) {
810 phys_addr_t upper = lmb_used[i].base +
811 lmb_used[i].size - 1;
812 if (addr >= lmb_used[i].base && addr <= upper)
813 return (lmb_used[i].flags & flags) == flags;
814 }
815 return 0;
816}
817
818static int lmb_setup(bool test)
819{
820 bool ret;
821
822 ret = alist_init(&lmb.available_mem, sizeof(struct lmb_region),
823 (uint)LMB_ALIST_INITIAL_SIZE);
824 if (!ret) {
825 log_debug("Unable to initialise the list for LMB free memory\n");
826 return -ENOMEM;
827 }
828
829 ret = alist_init(&lmb.used_mem, sizeof(struct lmb_region),
830 (uint)LMB_ALIST_INITIAL_SIZE);
831 if (!ret) {
832 log_debug("Unable to initialise the list for LMB used memory\n");
833 return -ENOMEM;
834 }
835
836 lmb.test = test;
837
838 return 0;
839}
840
841int lmb_init(void)
842{
843 int ret;
844
845 ret = lmb_setup(false);
846 if (ret) {
847 log_info("Unable to init LMB\n");
848 return ret;
849 }
850
851 lmb_add_memory();
852
853 /* Reserve the U-Boot image region once U-Boot has relocated */
854 if (xpl_phase() == PHASE_SPL)
855 lmb_reserve_common_spl();
856 else if (xpl_phase() == PHASE_BOARD_R)
857 lmb_reserve_common((void *)gd->fdt_blob);
858
859 return 0;
860}
861
862struct lmb *lmb_get(void)
863{
864 return &lmb;
865}
866
867#if CONFIG_IS_ENABLED(UNIT_TEST)
868int lmb_push(struct lmb *store)
869{
870 int ret;
871
872 *store = lmb;
873 ret = lmb_setup(true);
874 if (ret)
875 return ret;
876
877 return 0;
878}
879
880void lmb_pop(struct lmb *store)
881{
882 alist_uninit(&lmb.available_mem);
883 alist_uninit(&lmb.used_mem);
884 lmb = *store;
885}
886#endif /* UNIT_TEST */
This page took 0.039284 seconds and 5 git commands to generate.