]>
Commit | Line | Data |
---|---|---|
83d290c5 | 1 | // SPDX-License-Identifier: GPL-2.0+ |
4ed6552f KG |
2 | /* |
3 | * Procedures for maintaining information about logical memory blocks. | |
4 | * | |
5 | * Peter Bergner, IBM Corp. June 2001. | |
6 | * Copyright (C) 2001 Peter Bergner. | |
4ed6552f KG |
7 | */ |
8 | ||
9 | #include <common.h> | |
4d72caa5 | 10 | #include <image.h> |
4ed6552f | 11 | #include <lmb.h> |
f7ae49fc | 12 | #include <log.h> |
336d4615 | 13 | #include <malloc.h> |
4ed6552f KG |
14 | |
15 | #define LMB_ALLOC_ANYWHERE 0 | |
16 | ||
358c7789 | 17 | static void lmb_dump_region(struct lmb_region *rgn, char *name) |
4ed6552f | 18 | { |
358c7789 PD |
19 | unsigned long long base, size, end; |
20 | enum lmb_flags flags; | |
21 | int i; | |
4ed6552f | 22 | |
358c7789 | 23 | printf(" %s.cnt = 0x%lx\n", name, rgn->cnt); |
4ed6552f | 24 | |
358c7789 PD |
25 | for (i = 0; i < rgn->cnt; i++) { |
26 | base = rgn->region[i].base; | |
27 | size = rgn->region[i].size; | |
28 | end = base + size - 1; | |
29 | flags = rgn->region[i].flags; | |
30 | ||
31 | printf(" %s[%d]\t[0x%llx-0x%llx], 0x%08llx bytes flags: %x\n", | |
32 | name, i, base, end, size, flags); | |
4ed6552f | 33 | } |
9996cea7 TK |
34 | } |
35 | ||
358c7789 PD |
36 | void lmb_dump_all_force(struct lmb *lmb) |
37 | { | |
38 | printf("lmb_dump_all:\n"); | |
39 | lmb_dump_region(&lmb->memory, "memory"); | |
40 | lmb_dump_region(&lmb->reserved, "reserved"); | |
41 | } | |
42 | ||
9996cea7 TK |
43 | void lmb_dump_all(struct lmb *lmb) |
44 | { | |
45 | #ifdef DEBUG | |
46 | lmb_dump_all_force(lmb); | |
47 | #endif | |
4ed6552f KG |
48 | } |
49 | ||
e35d2a75 SG |
50 | static long lmb_addrs_overlap(phys_addr_t base1, phys_size_t size1, |
51 | phys_addr_t base2, phys_size_t size2) | |
4ed6552f | 52 | { |
d67f33cf SG |
53 | const phys_addr_t base1_end = base1 + size1 - 1; |
54 | const phys_addr_t base2_end = base2 + size2 - 1; | |
55 | ||
56 | return ((base1 <= base2_end) && (base2 <= base1_end)); | |
4ed6552f KG |
57 | } |
58 | ||
391fd93a | 59 | static long lmb_addrs_adjacent(phys_addr_t base1, phys_size_t size1, |
e35d2a75 | 60 | phys_addr_t base2, phys_size_t size2) |
4ed6552f KG |
61 | { |
62 | if (base2 == base1 + size1) | |
63 | return 1; | |
64 | else if (base1 == base2 + size2) | |
65 | return -1; | |
66 | ||
67 | return 0; | |
68 | } | |
69 | ||
e35d2a75 SG |
70 | static long lmb_regions_adjacent(struct lmb_region *rgn, unsigned long r1, |
71 | unsigned long r2) | |
4ed6552f | 72 | { |
391fd93a BB |
73 | phys_addr_t base1 = rgn->region[r1].base; |
74 | phys_size_t size1 = rgn->region[r1].size; | |
75 | phys_addr_t base2 = rgn->region[r2].base; | |
76 | phys_size_t size2 = rgn->region[r2].size; | |
4ed6552f KG |
77 | |
78 | return lmb_addrs_adjacent(base1, size1, base2, size2); | |
79 | } | |
80 | ||
81 | static void lmb_remove_region(struct lmb_region *rgn, unsigned long r) | |
82 | { | |
83 | unsigned long i; | |
84 | ||
85 | for (i = r; i < rgn->cnt - 1; i++) { | |
86 | rgn->region[i].base = rgn->region[i + 1].base; | |
87 | rgn->region[i].size = rgn->region[i + 1].size; | |
59c0ea5d | 88 | rgn->region[i].flags = rgn->region[i + 1].flags; |
4ed6552f KG |
89 | } |
90 | rgn->cnt--; | |
91 | } | |
92 | ||
93 | /* Assumption: base addr of region 1 < base addr of region 2 */ | |
e35d2a75 SG |
94 | static void lmb_coalesce_regions(struct lmb_region *rgn, unsigned long r1, |
95 | unsigned long r2) | |
4ed6552f KG |
96 | { |
97 | rgn->region[r1].size += rgn->region[r2].size; | |
98 | lmb_remove_region(rgn, r2); | |
99 | } | |
100 | ||
101 | void lmb_init(struct lmb *lmb) | |
102 | { | |
6d66502b | 103 | #if IS_ENABLED(CONFIG_LMB_USE_MAX_REGIONS) |
4fa0150d PD |
104 | lmb->memory.max = CONFIG_LMB_MAX_REGIONS; |
105 | lmb->reserved.max = CONFIG_LMB_MAX_REGIONS; | |
6d66502b PD |
106 | #else |
107 | lmb->memory.max = CONFIG_LMB_MEMORY_REGIONS; | |
108 | lmb->reserved.max = CONFIG_LMB_RESERVED_REGIONS; | |
109 | lmb->memory.region = lmb->memory_regions; | |
110 | lmb->reserved.region = lmb->reserved_regions; | |
111 | #endif | |
d67f33cf | 112 | lmb->memory.cnt = 0; |
d67f33cf | 113 | lmb->reserved.cnt = 0; |
4ed6552f KG |
114 | } |
115 | ||
9cc2323f | 116 | static void lmb_reserve_common(struct lmb *lmb, void *fdt_blob) |
aa3c609e | 117 | { |
aa3c609e SG |
118 | arch_lmb_reserve(lmb); |
119 | board_lmb_reserve(lmb); | |
120 | ||
121 | if (IMAGE_ENABLE_OF_LIBFDT && fdt_blob) | |
122 | boot_fdt_add_mem_rsv_regions(lmb, fdt_blob); | |
123 | } | |
124 | ||
9cc2323f | 125 | /* Initialize the struct, add memory and call arch/board reserve functions */ |
b75d8dc5 | 126 | void lmb_init_and_reserve(struct lmb *lmb, struct bd_info *bd, void *fdt_blob) |
9cc2323f | 127 | { |
9cc2323f | 128 | int i; |
9cc2323f SG |
129 | |
130 | lmb_init(lmb); | |
dfaf6a57 | 131 | |
9cc2323f SG |
132 | for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++) { |
133 | if (bd->bi_dram[i].size) { | |
134 | lmb_add(lmb, bd->bi_dram[i].start, | |
135 | bd->bi_dram[i].size); | |
136 | } | |
137 | } | |
dfaf6a57 | 138 | |
9cc2323f SG |
139 | lmb_reserve_common(lmb, fdt_blob); |
140 | } | |
141 | ||
142 | /* Initialize the struct, add memory and call arch/board reserve functions */ | |
143 | void lmb_init_and_reserve_range(struct lmb *lmb, phys_addr_t base, | |
144 | phys_size_t size, void *fdt_blob) | |
145 | { | |
146 | lmb_init(lmb); | |
147 | lmb_add(lmb, base, size); | |
148 | lmb_reserve_common(lmb, fdt_blob); | |
149 | } | |
150 | ||
4ed6552f | 151 | /* This routine called with relocation disabled. */ |
59c0ea5d PD |
152 | static long lmb_add_region_flags(struct lmb_region *rgn, phys_addr_t base, |
153 | phys_size_t size, enum lmb_flags flags) | |
4ed6552f KG |
154 | { |
155 | unsigned long coalesced = 0; | |
156 | long adjacent, i; | |
157 | ||
d67f33cf | 158 | if (rgn->cnt == 0) { |
4ed6552f KG |
159 | rgn->region[0].base = base; |
160 | rgn->region[0].size = size; | |
59c0ea5d | 161 | rgn->region[0].flags = flags; |
d67f33cf | 162 | rgn->cnt = 1; |
4ed6552f KG |
163 | return 0; |
164 | } | |
165 | ||
166 | /* First try and coalesce this LMB with another. */ | |
e35d2a75 | 167 | for (i = 0; i < rgn->cnt; i++) { |
391fd93a BB |
168 | phys_addr_t rgnbase = rgn->region[i].base; |
169 | phys_size_t rgnsize = rgn->region[i].size; | |
59c0ea5d PD |
170 | phys_size_t rgnflags = rgn->region[i].flags; |
171 | ||
172 | if (rgnbase == base && rgnsize == size) { | |
173 | if (flags == rgnflags) | |
174 | /* Already have this region, so we're done */ | |
175 | return 0; | |
176 | else | |
177 | return -1; /* regions with new flags */ | |
178 | } | |
4ed6552f | 179 | |
e35d2a75 SG |
180 | adjacent = lmb_addrs_adjacent(base, size, rgnbase, rgnsize); |
181 | if (adjacent > 0) { | |
59c0ea5d PD |
182 | if (flags != rgnflags) |
183 | break; | |
4ed6552f KG |
184 | rgn->region[i].base -= size; |
185 | rgn->region[i].size += size; | |
186 | coalesced++; | |
187 | break; | |
e35d2a75 | 188 | } else if (adjacent < 0) { |
59c0ea5d PD |
189 | if (flags != rgnflags) |
190 | break; | |
4ed6552f KG |
191 | rgn->region[i].size += size; |
192 | coalesced++; | |
193 | break; | |
0f7c51a6 SG |
194 | } else if (lmb_addrs_overlap(base, size, rgnbase, rgnsize)) { |
195 | /* regions overlap */ | |
196 | return -1; | |
4ed6552f KG |
197 | } |
198 | } | |
199 | ||
e35d2a75 | 200 | if ((i < rgn->cnt - 1) && lmb_regions_adjacent(rgn, i, i + 1)) { |
59c0ea5d PD |
201 | if (rgn->region[i].flags == rgn->region[i + 1].flags) { |
202 | lmb_coalesce_regions(rgn, i, i + 1); | |
203 | coalesced++; | |
204 | } | |
4ed6552f KG |
205 | } |
206 | ||
207 | if (coalesced) | |
208 | return coalesced; | |
00fd8dad | 209 | if (rgn->cnt >= rgn->max) |
4ed6552f KG |
210 | return -1; |
211 | ||
212 | /* Couldn't coalesce the LMB, so add it to the sorted table. */ | |
213 | for (i = rgn->cnt-1; i >= 0; i--) { | |
214 | if (base < rgn->region[i].base) { | |
e35d2a75 SG |
215 | rgn->region[i + 1].base = rgn->region[i].base; |
216 | rgn->region[i + 1].size = rgn->region[i].size; | |
59c0ea5d | 217 | rgn->region[i + 1].flags = rgn->region[i].flags; |
4ed6552f | 218 | } else { |
e35d2a75 SG |
219 | rgn->region[i + 1].base = base; |
220 | rgn->region[i + 1].size = size; | |
59c0ea5d | 221 | rgn->region[i + 1].flags = flags; |
4ed6552f KG |
222 | break; |
223 | } | |
224 | } | |
225 | ||
226 | if (base < rgn->region[0].base) { | |
227 | rgn->region[0].base = base; | |
228 | rgn->region[0].size = size; | |
59c0ea5d | 229 | rgn->region[0].flags = flags; |
4ed6552f KG |
230 | } |
231 | ||
232 | rgn->cnt++; | |
233 | ||
234 | return 0; | |
235 | } | |
236 | ||
59c0ea5d PD |
237 | static long lmb_add_region(struct lmb_region *rgn, phys_addr_t base, |
238 | phys_size_t size) | |
239 | { | |
240 | return lmb_add_region_flags(rgn, base, size, LMB_NONE); | |
241 | } | |
242 | ||
4ed6552f | 243 | /* This routine may be called with relocation disabled. */ |
391fd93a | 244 | long lmb_add(struct lmb *lmb, phys_addr_t base, phys_size_t size) |
4ed6552f KG |
245 | { |
246 | struct lmb_region *_rgn = &(lmb->memory); | |
247 | ||
248 | return lmb_add_region(_rgn, base, size); | |
249 | } | |
250 | ||
98874ff3 | 251 | long lmb_free(struct lmb *lmb, phys_addr_t base, phys_size_t size) |
63796c4e AF |
252 | { |
253 | struct lmb_region *rgn = &(lmb->reserved); | |
98874ff3 | 254 | phys_addr_t rgnbegin, rgnend; |
d67f33cf | 255 | phys_addr_t end = base + size - 1; |
63796c4e AF |
256 | int i; |
257 | ||
258 | rgnbegin = rgnend = 0; /* supress gcc warnings */ | |
259 | ||
260 | /* Find the region where (base, size) belongs to */ | |
e35d2a75 | 261 | for (i = 0; i < rgn->cnt; i++) { |
63796c4e | 262 | rgnbegin = rgn->region[i].base; |
d67f33cf | 263 | rgnend = rgnbegin + rgn->region[i].size - 1; |
63796c4e AF |
264 | |
265 | if ((rgnbegin <= base) && (end <= rgnend)) | |
266 | break; | |
267 | } | |
268 | ||
269 | /* Didn't find the region */ | |
270 | if (i == rgn->cnt) | |
271 | return -1; | |
272 | ||
273 | /* Check to see if we are removing entire region */ | |
274 | if ((rgnbegin == base) && (rgnend == end)) { | |
275 | lmb_remove_region(rgn, i); | |
276 | return 0; | |
277 | } | |
278 | ||
279 | /* Check to see if region is matching at the front */ | |
280 | if (rgnbegin == base) { | |
d67f33cf | 281 | rgn->region[i].base = end + 1; |
63796c4e AF |
282 | rgn->region[i].size -= size; |
283 | return 0; | |
284 | } | |
285 | ||
286 | /* Check to see if the region is matching at the end */ | |
287 | if (rgnend == end) { | |
288 | rgn->region[i].size -= size; | |
289 | return 0; | |
290 | } | |
291 | ||
292 | /* | |
293 | * We need to split the entry - adjust the current one to the | |
294 | * beginging of the hole and add the region after hole. | |
295 | */ | |
296 | rgn->region[i].size = base - rgn->region[i].base; | |
59c0ea5d PD |
297 | return lmb_add_region_flags(rgn, end + 1, rgnend - end, |
298 | rgn->region[i].flags); | |
63796c4e AF |
299 | } |
300 | ||
59c0ea5d PD |
301 | long lmb_reserve_flags(struct lmb *lmb, phys_addr_t base, phys_size_t size, |
302 | enum lmb_flags flags) | |
4ed6552f KG |
303 | { |
304 | struct lmb_region *_rgn = &(lmb->reserved); | |
305 | ||
59c0ea5d PD |
306 | return lmb_add_region_flags(_rgn, base, size, flags); |
307 | } | |
308 | ||
309 | long lmb_reserve(struct lmb *lmb, phys_addr_t base, phys_size_t size) | |
310 | { | |
311 | return lmb_reserve_flags(lmb, base, size, LMB_NONE); | |
4ed6552f KG |
312 | } |
313 | ||
750a6ff4 | 314 | static long lmb_overlaps_region(struct lmb_region *rgn, phys_addr_t base, |
391fd93a | 315 | phys_size_t size) |
4ed6552f KG |
316 | { |
317 | unsigned long i; | |
318 | ||
e35d2a75 | 319 | for (i = 0; i < rgn->cnt; i++) { |
391fd93a BB |
320 | phys_addr_t rgnbase = rgn->region[i].base; |
321 | phys_size_t rgnsize = rgn->region[i].size; | |
e35d2a75 | 322 | if (lmb_addrs_overlap(base, size, rgnbase, rgnsize)) |
4ed6552f | 323 | break; |
4ed6552f KG |
324 | } |
325 | ||
326 | return (i < rgn->cnt) ? i : -1; | |
327 | } | |
328 | ||
391fd93a | 329 | phys_addr_t lmb_alloc(struct lmb *lmb, phys_size_t size, ulong align) |
4ed6552f KG |
330 | { |
331 | return lmb_alloc_base(lmb, size, align, LMB_ALLOC_ANYWHERE); | |
332 | } | |
333 | ||
391fd93a | 334 | phys_addr_t lmb_alloc_base(struct lmb *lmb, phys_size_t size, ulong align, phys_addr_t max_addr) |
4ed6552f | 335 | { |
391fd93a | 336 | phys_addr_t alloc; |
4ed6552f KG |
337 | |
338 | alloc = __lmb_alloc_base(lmb, size, align, max_addr); | |
339 | ||
340 | if (alloc == 0) | |
341 | printf("ERROR: Failed to allocate 0x%lx bytes below 0x%lx.\n", | |
e35d2a75 | 342 | (ulong)size, (ulong)max_addr); |
4ed6552f KG |
343 | |
344 | return alloc; | |
345 | } | |
346 | ||
391fd93a | 347 | static phys_addr_t lmb_align_down(phys_addr_t addr, phys_size_t size) |
4ed6552f KG |
348 | { |
349 | return addr & ~(size - 1); | |
350 | } | |
351 | ||
391fd93a | 352 | phys_addr_t __lmb_alloc_base(struct lmb *lmb, phys_size_t size, ulong align, phys_addr_t max_addr) |
4ed6552f | 353 | { |
e35d2a75 | 354 | long i, rgn; |
391fd93a | 355 | phys_addr_t base = 0; |
7570a994 | 356 | phys_addr_t res_base; |
4ed6552f | 357 | |
e35d2a75 | 358 | for (i = lmb->memory.cnt - 1; i >= 0; i--) { |
391fd93a BB |
359 | phys_addr_t lmbbase = lmb->memory.region[i].base; |
360 | phys_size_t lmbsize = lmb->memory.region[i].size; | |
4ed6552f | 361 | |
7570a994 AF |
362 | if (lmbsize < size) |
363 | continue; | |
4ed6552f KG |
364 | if (max_addr == LMB_ALLOC_ANYWHERE) |
365 | base = lmb_align_down(lmbbase + lmbsize - size, align); | |
366 | else if (lmbbase < max_addr) { | |
ad3fda52 SW |
367 | base = lmbbase + lmbsize; |
368 | if (base < lmbbase) | |
369 | base = -1; | |
370 | base = min(base, max_addr); | |
4ed6552f KG |
371 | base = lmb_align_down(base - size, align); |
372 | } else | |
373 | continue; | |
374 | ||
7570a994 | 375 | while (base && lmbbase <= base) { |
e35d2a75 SG |
376 | rgn = lmb_overlaps_region(&lmb->reserved, base, size); |
377 | if (rgn < 0) { | |
7570a994 AF |
378 | /* This area isn't reserved, take it */ |
379 | if (lmb_add_region(&lmb->reserved, base, | |
0f7c51a6 | 380 | size) < 0) |
7570a994 AF |
381 | return 0; |
382 | return base; | |
383 | } | |
e35d2a75 | 384 | res_base = lmb->reserved.region[rgn].base; |
7570a994 AF |
385 | if (res_base < size) |
386 | break; | |
387 | base = lmb_align_down(res_base - size, align); | |
388 | } | |
4ed6552f | 389 | } |
7570a994 | 390 | return 0; |
4ed6552f KG |
391 | } |
392 | ||
4cc8af80 SG |
393 | /* |
394 | * Try to allocate a specific address range: must be in defined memory but not | |
395 | * reserved | |
396 | */ | |
397 | phys_addr_t lmb_alloc_addr(struct lmb *lmb, phys_addr_t base, phys_size_t size) | |
398 | { | |
e35d2a75 | 399 | long rgn; |
4cc8af80 SG |
400 | |
401 | /* Check if the requested address is in one of the memory regions */ | |
e35d2a75 SG |
402 | rgn = lmb_overlaps_region(&lmb->memory, base, size); |
403 | if (rgn >= 0) { | |
4cc8af80 SG |
404 | /* |
405 | * Check if the requested end address is in the same memory | |
406 | * region we found. | |
407 | */ | |
e35d2a75 SG |
408 | if (lmb_addrs_overlap(lmb->memory.region[rgn].base, |
409 | lmb->memory.region[rgn].size, | |
410 | base + size - 1, 1)) { | |
4cc8af80 SG |
411 | /* ok, reserve the memory */ |
412 | if (lmb_reserve(lmb, base, size) >= 0) | |
413 | return base; | |
414 | } | |
415 | } | |
416 | return 0; | |
417 | } | |
418 | ||
419 | /* Return number of bytes from a given address that are free */ | |
65304aad | 420 | phys_size_t lmb_get_free_size(struct lmb *lmb, phys_addr_t addr) |
4cc8af80 SG |
421 | { |
422 | int i; | |
e35d2a75 | 423 | long rgn; |
4cc8af80 SG |
424 | |
425 | /* check if the requested address is in the memory regions */ | |
e35d2a75 SG |
426 | rgn = lmb_overlaps_region(&lmb->memory, addr, 1); |
427 | if (rgn >= 0) { | |
4cc8af80 SG |
428 | for (i = 0; i < lmb->reserved.cnt; i++) { |
429 | if (addr < lmb->reserved.region[i].base) { | |
430 | /* first reserved range > requested address */ | |
431 | return lmb->reserved.region[i].base - addr; | |
432 | } | |
433 | if (lmb->reserved.region[i].base + | |
434 | lmb->reserved.region[i].size > addr) { | |
435 | /* requested addr is in this reserved range */ | |
436 | return 0; | |
437 | } | |
438 | } | |
439 | /* if we come here: no reserved ranges above requested addr */ | |
440 | return lmb->memory.region[lmb->memory.cnt - 1].base + | |
441 | lmb->memory.region[lmb->memory.cnt - 1].size - addr; | |
442 | } | |
443 | return 0; | |
444 | } | |
445 | ||
e359a4a5 | 446 | int lmb_is_reserved_flags(struct lmb *lmb, phys_addr_t addr, int flags) |
4ed6552f KG |
447 | { |
448 | int i; | |
449 | ||
450 | for (i = 0; i < lmb->reserved.cnt; i++) { | |
391fd93a | 451 | phys_addr_t upper = lmb->reserved.region[i].base + |
4ed6552f KG |
452 | lmb->reserved.region[i].size - 1; |
453 | if ((addr >= lmb->reserved.region[i].base) && (addr <= upper)) | |
e359a4a5 | 454 | return (lmb->reserved.region[i].flags & flags) == flags; |
4ed6552f KG |
455 | } |
456 | return 0; | |
457 | } | |
a16028da | 458 | |
e359a4a5 PD |
459 | int lmb_is_reserved(struct lmb *lmb, phys_addr_t addr) |
460 | { | |
461 | return lmb_is_reserved_flags(lmb, addr, LMB_NONE); | |
462 | } | |
463 | ||
2c34f3f5 | 464 | __weak void board_lmb_reserve(struct lmb *lmb) |
a16028da MF |
465 | { |
466 | /* please define platform specific board_lmb_reserve() */ | |
467 | } | |
a16028da | 468 | |
2c34f3f5 | 469 | __weak void arch_lmb_reserve(struct lmb *lmb) |
a16028da MF |
470 | { |
471 | /* please define platform specific arch_lmb_reserve() */ | |
472 | } |