]>
git.ipfire.org Git - thirdparty/u-boot.git/blob - lib/lmb.c
1 // SPDX-License-Identifier: GPL-2.0+
3 * Procedures for maintaining information about logical memory blocks.
5 * Peter Bergner, IBM Corp. June 2001.
6 * Copyright (C) 2001 Peter Bergner.
14 #define LMB_ALLOC_ANYWHERE 0
16 void lmb_dump_all(struct lmb
*lmb
)
21 debug("lmb_dump_all:\n");
22 debug(" memory.cnt = 0x%lx\n", lmb
->memory
.cnt
);
23 debug(" memory.size = 0x%llx\n",
24 (unsigned long long)lmb
->memory
.size
);
25 for (i
= 0; i
< lmb
->memory
.cnt
; i
++) {
26 debug(" memory.reg[0x%lx].base = 0x%llx\n", i
,
27 (unsigned long long)lmb
->memory
.region
[i
].base
);
28 debug(" .size = 0x%llx\n",
29 (unsigned long long)lmb
->memory
.region
[i
].size
);
32 debug("\n reserved.cnt = 0x%lx\n",
34 debug(" reserved.size = 0x%llx\n",
35 (unsigned long long)lmb
->reserved
.size
);
36 for (i
= 0; i
< lmb
->reserved
.cnt
; i
++) {
37 debug(" reserved.reg[0x%lx].base = 0x%llx\n", i
,
38 (unsigned long long)lmb
->reserved
.region
[i
].base
);
39 debug(" .size = 0x%llx\n",
40 (unsigned long long)lmb
->reserved
.region
[i
].size
);
45 static long lmb_addrs_overlap(phys_addr_t base1
, phys_size_t size1
,
46 phys_addr_t base2
, phys_size_t size2
)
48 const phys_addr_t base1_end
= base1
+ size1
- 1;
49 const phys_addr_t base2_end
= base2
+ size2
- 1;
51 return ((base1
<= base2_end
) && (base2
<= base1_end
));
54 static long lmb_addrs_adjacent(phys_addr_t base1
, phys_size_t size1
,
55 phys_addr_t base2
, phys_size_t size2
)
57 if (base2
== base1
+ size1
)
59 else if (base1
== base2
+ size2
)
65 static long lmb_regions_adjacent(struct lmb_region
*rgn
, unsigned long r1
,
68 phys_addr_t base1
= rgn
->region
[r1
].base
;
69 phys_size_t size1
= rgn
->region
[r1
].size
;
70 phys_addr_t base2
= rgn
->region
[r2
].base
;
71 phys_size_t size2
= rgn
->region
[r2
].size
;
73 return lmb_addrs_adjacent(base1
, size1
, base2
, size2
);
76 static void lmb_remove_region(struct lmb_region
*rgn
, unsigned long r
)
80 for (i
= r
; i
< rgn
->cnt
- 1; i
++) {
81 rgn
->region
[i
].base
= rgn
->region
[i
+ 1].base
;
82 rgn
->region
[i
].size
= rgn
->region
[i
+ 1].size
;
87 /* Assumption: base addr of region 1 < base addr of region 2 */
88 static void lmb_coalesce_regions(struct lmb_region
*rgn
, unsigned long r1
,
91 rgn
->region
[r1
].size
+= rgn
->region
[r2
].size
;
92 lmb_remove_region(rgn
, r2
);
95 void lmb_init(struct lmb
*lmb
)
99 lmb
->reserved
.cnt
= 0;
100 lmb
->reserved
.size
= 0;
103 static void lmb_reserve_common(struct lmb
*lmb
, void *fdt_blob
)
105 arch_lmb_reserve(lmb
);
106 board_lmb_reserve(lmb
);
108 if (IMAGE_ENABLE_OF_LIBFDT
&& fdt_blob
)
109 boot_fdt_add_mem_rsv_regions(lmb
, fdt_blob
);
112 /* Initialize the struct, add memory and call arch/board reserve functions */
113 void lmb_init_and_reserve(struct lmb
*lmb
, bd_t
*bd
, void *fdt_blob
)
115 #ifdef CONFIG_NR_DRAM_BANKS
120 #ifdef CONFIG_NR_DRAM_BANKS
121 for (i
= 0; i
< CONFIG_NR_DRAM_BANKS
; i
++) {
122 if (bd
->bi_dram
[i
].size
) {
123 lmb_add(lmb
, bd
->bi_dram
[i
].start
,
124 bd
->bi_dram
[i
].size
);
129 lmb_add(lmb
, bd
->bi_memstart
, bd
->bi_memsize
);
131 lmb_reserve_common(lmb
, fdt_blob
);
134 /* Initialize the struct, add memory and call arch/board reserve functions */
135 void lmb_init_and_reserve_range(struct lmb
*lmb
, phys_addr_t base
,
136 phys_size_t size
, void *fdt_blob
)
139 lmb_add(lmb
, base
, size
);
140 lmb_reserve_common(lmb
, fdt_blob
);
143 /* This routine called with relocation disabled. */
144 static long lmb_add_region(struct lmb_region
*rgn
, phys_addr_t base
, phys_size_t size
)
146 unsigned long coalesced
= 0;
150 rgn
->region
[0].base
= base
;
151 rgn
->region
[0].size
= size
;
156 /* First try and coalesce this LMB with another. */
157 for (i
= 0; i
< rgn
->cnt
; i
++) {
158 phys_addr_t rgnbase
= rgn
->region
[i
].base
;
159 phys_size_t rgnsize
= rgn
->region
[i
].size
;
161 if ((rgnbase
== base
) && (rgnsize
== size
))
162 /* Already have this region, so we're done */
165 adjacent
= lmb_addrs_adjacent(base
, size
, rgnbase
, rgnsize
);
167 rgn
->region
[i
].base
-= size
;
168 rgn
->region
[i
].size
+= size
;
171 } else if (adjacent
< 0) {
172 rgn
->region
[i
].size
+= size
;
175 } else if (lmb_addrs_overlap(base
, size
, rgnbase
, rgnsize
)) {
176 /* regions overlap */
181 if ((i
< rgn
->cnt
- 1) && lmb_regions_adjacent(rgn
, i
, i
+ 1)) {
182 lmb_coalesce_regions(rgn
, i
, i
+ 1);
188 if (rgn
->cnt
>= MAX_LMB_REGIONS
)
191 /* Couldn't coalesce the LMB, so add it to the sorted table. */
192 for (i
= rgn
->cnt
-1; i
>= 0; i
--) {
193 if (base
< rgn
->region
[i
].base
) {
194 rgn
->region
[i
+ 1].base
= rgn
->region
[i
].base
;
195 rgn
->region
[i
+ 1].size
= rgn
->region
[i
].size
;
197 rgn
->region
[i
+ 1].base
= base
;
198 rgn
->region
[i
+ 1].size
= size
;
203 if (base
< rgn
->region
[0].base
) {
204 rgn
->region
[0].base
= base
;
205 rgn
->region
[0].size
= size
;
213 /* This routine may be called with relocation disabled. */
214 long lmb_add(struct lmb
*lmb
, phys_addr_t base
, phys_size_t size
)
216 struct lmb_region
*_rgn
= &(lmb
->memory
);
218 return lmb_add_region(_rgn
, base
, size
);
221 long lmb_free(struct lmb
*lmb
, phys_addr_t base
, phys_size_t size
)
223 struct lmb_region
*rgn
= &(lmb
->reserved
);
224 phys_addr_t rgnbegin
, rgnend
;
225 phys_addr_t end
= base
+ size
- 1;
228 rgnbegin
= rgnend
= 0; /* supress gcc warnings */
230 /* Find the region where (base, size) belongs to */
231 for (i
= 0; i
< rgn
->cnt
; i
++) {
232 rgnbegin
= rgn
->region
[i
].base
;
233 rgnend
= rgnbegin
+ rgn
->region
[i
].size
- 1;
235 if ((rgnbegin
<= base
) && (end
<= rgnend
))
239 /* Didn't find the region */
243 /* Check to see if we are removing entire region */
244 if ((rgnbegin
== base
) && (rgnend
== end
)) {
245 lmb_remove_region(rgn
, i
);
249 /* Check to see if region is matching at the front */
250 if (rgnbegin
== base
) {
251 rgn
->region
[i
].base
= end
+ 1;
252 rgn
->region
[i
].size
-= size
;
256 /* Check to see if the region is matching at the end */
258 rgn
->region
[i
].size
-= size
;
263 * We need to split the entry - adjust the current one to the
264 * beginging of the hole and add the region after hole.
266 rgn
->region
[i
].size
= base
- rgn
->region
[i
].base
;
267 return lmb_add_region(rgn
, end
+ 1, rgnend
- end
);
270 long lmb_reserve(struct lmb
*lmb
, phys_addr_t base
, phys_size_t size
)
272 struct lmb_region
*_rgn
= &(lmb
->reserved
);
274 return lmb_add_region(_rgn
, base
, size
);
277 static long lmb_overlaps_region(struct lmb_region
*rgn
, phys_addr_t base
,
282 for (i
= 0; i
< rgn
->cnt
; i
++) {
283 phys_addr_t rgnbase
= rgn
->region
[i
].base
;
284 phys_size_t rgnsize
= rgn
->region
[i
].size
;
285 if (lmb_addrs_overlap(base
, size
, rgnbase
, rgnsize
))
289 return (i
< rgn
->cnt
) ? i
: -1;
292 phys_addr_t
lmb_alloc(struct lmb
*lmb
, phys_size_t size
, ulong align
)
294 return lmb_alloc_base(lmb
, size
, align
, LMB_ALLOC_ANYWHERE
);
297 phys_addr_t
lmb_alloc_base(struct lmb
*lmb
, phys_size_t size
, ulong align
, phys_addr_t max_addr
)
301 alloc
= __lmb_alloc_base(lmb
, size
, align
, max_addr
);
304 printf("ERROR: Failed to allocate 0x%lx bytes below 0x%lx.\n",
305 (ulong
)size
, (ulong
)max_addr
);
310 static phys_addr_t
lmb_align_down(phys_addr_t addr
, phys_size_t size
)
312 return addr
& ~(size
- 1);
315 phys_addr_t
__lmb_alloc_base(struct lmb
*lmb
, phys_size_t size
, ulong align
, phys_addr_t max_addr
)
318 phys_addr_t base
= 0;
319 phys_addr_t res_base
;
321 for (i
= lmb
->memory
.cnt
- 1; i
>= 0; i
--) {
322 phys_addr_t lmbbase
= lmb
->memory
.region
[i
].base
;
323 phys_size_t lmbsize
= lmb
->memory
.region
[i
].size
;
327 if (max_addr
== LMB_ALLOC_ANYWHERE
)
328 base
= lmb_align_down(lmbbase
+ lmbsize
- size
, align
);
329 else if (lmbbase
< max_addr
) {
330 base
= lmbbase
+ lmbsize
;
333 base
= min(base
, max_addr
);
334 base
= lmb_align_down(base
- size
, align
);
338 while (base
&& lmbbase
<= base
) {
339 rgn
= lmb_overlaps_region(&lmb
->reserved
, base
, size
);
341 /* This area isn't reserved, take it */
342 if (lmb_add_region(&lmb
->reserved
, base
,
347 res_base
= lmb
->reserved
.region
[rgn
].base
;
350 base
= lmb_align_down(res_base
- size
, align
);
357 * Try to allocate a specific address range: must be in defined memory but not
360 phys_addr_t
lmb_alloc_addr(struct lmb
*lmb
, phys_addr_t base
, phys_size_t size
)
364 /* Check if the requested address is in one of the memory regions */
365 rgn
= lmb_overlaps_region(&lmb
->memory
, base
, size
);
368 * Check if the requested end address is in the same memory
371 if (lmb_addrs_overlap(lmb
->memory
.region
[rgn
].base
,
372 lmb
->memory
.region
[rgn
].size
,
373 base
+ size
- 1, 1)) {
374 /* ok, reserve the memory */
375 if (lmb_reserve(lmb
, base
, size
) >= 0)
382 /* Return number of bytes from a given address that are free */
383 phys_size_t
lmb_get_free_size(struct lmb
*lmb
, phys_addr_t addr
)
388 /* check if the requested address is in the memory regions */
389 rgn
= lmb_overlaps_region(&lmb
->memory
, addr
, 1);
391 for (i
= 0; i
< lmb
->reserved
.cnt
; i
++) {
392 if (addr
< lmb
->reserved
.region
[i
].base
) {
393 /* first reserved range > requested address */
394 return lmb
->reserved
.region
[i
].base
- addr
;
396 if (lmb
->reserved
.region
[i
].base
+
397 lmb
->reserved
.region
[i
].size
> addr
) {
398 /* requested addr is in this reserved range */
402 /* if we come here: no reserved ranges above requested addr */
403 return lmb
->memory
.region
[lmb
->memory
.cnt
- 1].base
+
404 lmb
->memory
.region
[lmb
->memory
.cnt
- 1].size
- addr
;
409 int lmb_is_reserved(struct lmb
*lmb
, phys_addr_t addr
)
413 for (i
= 0; i
< lmb
->reserved
.cnt
; i
++) {
414 phys_addr_t upper
= lmb
->reserved
.region
[i
].base
+
415 lmb
->reserved
.region
[i
].size
- 1;
416 if ((addr
>= lmb
->reserved
.region
[i
].base
) && (addr
<= upper
))
422 __weak
void board_lmb_reserve(struct lmb
*lmb
)
424 /* please define platform specific board_lmb_reserve() */
427 __weak
void arch_lmb_reserve(struct lmb
*lmb
)
429 /* please define platform specific arch_lmb_reserve() */