]>
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 | ||
06d514d7 | 9 | #include <efi_loader.h> |
4d72caa5 | 10 | #include <image.h> |
06d514d7 | 11 | #include <mapmem.h> |
4ed6552f | 12 | #include <lmb.h> |
f7ae49fc | 13 | #include <log.h> |
336d4615 | 14 | #include <malloc.h> |
4ed6552f | 15 | |
1274698d | 16 | #include <asm/global_data.h> |
bd994c00 | 17 | #include <asm/sections.h> |
1274698d MV |
18 | |
19 | DECLARE_GLOBAL_DATA_PTR; | |
20 | ||
4ed6552f KG |
21 | #define LMB_ALLOC_ANYWHERE 0 |
22 | ||
358c7789 | 23 | static void lmb_dump_region(struct lmb_region *rgn, char *name) |
4ed6552f | 24 | { |
358c7789 PD |
25 | unsigned long long base, size, end; |
26 | enum lmb_flags flags; | |
27 | int i; | |
4ed6552f | 28 | |
c9eb37a1 | 29 | printf(" %s.cnt = 0x%lx / max = 0x%lx\n", name, rgn->cnt, rgn->max); |
4ed6552f | 30 | |
358c7789 PD |
31 | for (i = 0; i < rgn->cnt; i++) { |
32 | base = rgn->region[i].base; | |
33 | size = rgn->region[i].size; | |
34 | end = base + size - 1; | |
35 | flags = rgn->region[i].flags; | |
36 | ||
37 | printf(" %s[%d]\t[0x%llx-0x%llx], 0x%08llx bytes flags: %x\n", | |
38 | name, i, base, end, size, flags); | |
4ed6552f | 39 | } |
9996cea7 TK |
40 | } |
41 | ||
358c7789 PD |
42 | void lmb_dump_all_force(struct lmb *lmb) |
43 | { | |
44 | printf("lmb_dump_all:\n"); | |
45 | lmb_dump_region(&lmb->memory, "memory"); | |
46 | lmb_dump_region(&lmb->reserved, "reserved"); | |
47 | } | |
48 | ||
9996cea7 TK |
49 | void lmb_dump_all(struct lmb *lmb) |
50 | { | |
51 | #ifdef DEBUG | |
52 | lmb_dump_all_force(lmb); | |
53 | #endif | |
4ed6552f KG |
54 | } |
55 | ||
e35d2a75 SG |
56 | static long lmb_addrs_overlap(phys_addr_t base1, phys_size_t size1, |
57 | phys_addr_t base2, phys_size_t size2) | |
4ed6552f | 58 | { |
d67f33cf SG |
59 | const phys_addr_t base1_end = base1 + size1 - 1; |
60 | const phys_addr_t base2_end = base2 + size2 - 1; | |
61 | ||
62 | return ((base1 <= base2_end) && (base2 <= base1_end)); | |
4ed6552f KG |
63 | } |
64 | ||
391fd93a | 65 | static long lmb_addrs_adjacent(phys_addr_t base1, phys_size_t size1, |
e35d2a75 | 66 | phys_addr_t base2, phys_size_t size2) |
4ed6552f KG |
67 | { |
68 | if (base2 == base1 + size1) | |
69 | return 1; | |
70 | else if (base1 == base2 + size2) | |
71 | return -1; | |
72 | ||
73 | return 0; | |
74 | } | |
75 | ||
edb5824b UK |
76 | static long lmb_regions_overlap(struct lmb_region *rgn, unsigned long r1, |
77 | unsigned long r2) | |
78 | { | |
79 | phys_addr_t base1 = rgn->region[r1].base; | |
80 | phys_size_t size1 = rgn->region[r1].size; | |
81 | phys_addr_t base2 = rgn->region[r2].base; | |
82 | phys_size_t size2 = rgn->region[r2].size; | |
83 | ||
84 | return lmb_addrs_overlap(base1, size1, base2, size2); | |
85 | } | |
e35d2a75 SG |
86 | static long lmb_regions_adjacent(struct lmb_region *rgn, unsigned long r1, |
87 | unsigned long r2) | |
4ed6552f | 88 | { |
391fd93a BB |
89 | phys_addr_t base1 = rgn->region[r1].base; |
90 | phys_size_t size1 = rgn->region[r1].size; | |
91 | phys_addr_t base2 = rgn->region[r2].base; | |
92 | phys_size_t size2 = rgn->region[r2].size; | |
4ed6552f KG |
93 | return lmb_addrs_adjacent(base1, size1, base2, size2); |
94 | } | |
95 | ||
96 | static void lmb_remove_region(struct lmb_region *rgn, unsigned long r) | |
97 | { | |
98 | unsigned long i; | |
99 | ||
100 | for (i = r; i < rgn->cnt - 1; i++) { | |
101 | rgn->region[i].base = rgn->region[i + 1].base; | |
102 | rgn->region[i].size = rgn->region[i + 1].size; | |
59c0ea5d | 103 | rgn->region[i].flags = rgn->region[i + 1].flags; |
4ed6552f KG |
104 | } |
105 | rgn->cnt--; | |
106 | } | |
107 | ||
108 | /* Assumption: base addr of region 1 < base addr of region 2 */ | |
e35d2a75 SG |
109 | static void lmb_coalesce_regions(struct lmb_region *rgn, unsigned long r1, |
110 | unsigned long r2) | |
4ed6552f KG |
111 | { |
112 | rgn->region[r1].size += rgn->region[r2].size; | |
113 | lmb_remove_region(rgn, r2); | |
114 | } | |
115 | ||
edb5824b UK |
116 | /*Assumption : base addr of region 1 < base addr of region 2*/ |
117 | static void lmb_fix_over_lap_regions(struct lmb_region *rgn, unsigned long r1, | |
118 | unsigned long r2) | |
119 | { | |
120 | phys_addr_t base1 = rgn->region[r1].base; | |
121 | phys_size_t size1 = rgn->region[r1].size; | |
122 | phys_addr_t base2 = rgn->region[r2].base; | |
123 | phys_size_t size2 = rgn->region[r2].size; | |
124 | ||
125 | if (base1 + size1 > base2 + size2) { | |
126 | printf("This will not be a case any time\n"); | |
127 | return; | |
128 | } | |
129 | rgn->region[r1].size = base2 + size2 - base1; | |
130 | lmb_remove_region(rgn, r2); | |
131 | } | |
132 | ||
4ed6552f KG |
133 | void lmb_init(struct lmb *lmb) |
134 | { | |
6d66502b | 135 | #if IS_ENABLED(CONFIG_LMB_USE_MAX_REGIONS) |
4fa0150d PD |
136 | lmb->memory.max = CONFIG_LMB_MAX_REGIONS; |
137 | lmb->reserved.max = CONFIG_LMB_MAX_REGIONS; | |
94c8da21 | 138 | #else |
6d66502b PD |
139 | lmb->memory.max = CONFIG_LMB_MEMORY_REGIONS; |
140 | lmb->reserved.max = CONFIG_LMB_RESERVED_REGIONS; | |
141 | lmb->memory.region = lmb->memory_regions; | |
142 | lmb->reserved.region = lmb->reserved_regions; | |
143 | #endif | |
d67f33cf | 144 | lmb->memory.cnt = 0; |
d67f33cf | 145 | lmb->reserved.cnt = 0; |
4ed6552f KG |
146 | } |
147 | ||
1274698d MV |
148 | void arch_lmb_reserve_generic(struct lmb *lmb, ulong sp, ulong end, ulong align) |
149 | { | |
150 | ulong bank_end; | |
151 | int bank; | |
152 | ||
153 | /* | |
154 | * Reserve memory from aligned address below the bottom of U-Boot stack | |
155 | * until end of U-Boot area using LMB to prevent U-Boot from overwriting | |
156 | * that memory. | |
157 | */ | |
158 | debug("## Current stack ends at 0x%08lx ", sp); | |
159 | ||
160 | /* adjust sp by 4K to be safe */ | |
161 | sp -= align; | |
162 | for (bank = 0; bank < CONFIG_NR_DRAM_BANKS; bank++) { | |
163 | if (!gd->bd->bi_dram[bank].size || | |
164 | sp < gd->bd->bi_dram[bank].start) | |
165 | continue; | |
166 | /* Watch out for RAM at end of address space! */ | |
167 | bank_end = gd->bd->bi_dram[bank].start + | |
168 | gd->bd->bi_dram[bank].size - 1; | |
169 | if (sp > bank_end) | |
170 | continue; | |
171 | if (bank_end > end) | |
172 | bank_end = end - 1; | |
173 | ||
174 | lmb_reserve(lmb, sp, bank_end - sp + 1); | |
bd994c00 MV |
175 | |
176 | if (gd->flags & GD_FLG_SKIP_RELOC) | |
177 | lmb_reserve(lmb, (phys_addr_t)(uintptr_t)_start, gd->mon_len); | |
178 | ||
1274698d MV |
179 | break; |
180 | } | |
181 | } | |
182 | ||
06d514d7 HS |
183 | /** |
184 | * efi_lmb_reserve() - add reservations for EFI memory | |
185 | * | |
186 | * Add reservations for all EFI memory areas that are not | |
187 | * EFI_CONVENTIONAL_MEMORY. | |
188 | * | |
189 | * @lmb: lmb environment | |
190 | * Return: 0 on success, 1 on failure | |
191 | */ | |
192 | static __maybe_unused int efi_lmb_reserve(struct lmb *lmb) | |
193 | { | |
194 | struct efi_mem_desc *memmap = NULL, *map; | |
195 | efi_uintn_t i, map_size = 0; | |
196 | efi_status_t ret; | |
197 | ||
198 | ret = efi_get_memory_map_alloc(&map_size, &memmap); | |
199 | if (ret != EFI_SUCCESS) | |
200 | return 1; | |
201 | ||
202 | for (i = 0, map = memmap; i < map_size / sizeof(*map); ++map, ++i) { | |
c5279ea1 SS |
203 | if (map->type != EFI_CONVENTIONAL_MEMORY) { |
204 | lmb_reserve_flags(lmb, | |
205 | map_to_sysmem((void *)(uintptr_t) | |
206 | map->physical_start), | |
207 | map->num_pages * EFI_PAGE_SIZE, | |
208 | map->type == EFI_RESERVED_MEMORY_TYPE | |
209 | ? LMB_NOMAP : LMB_NONE); | |
210 | } | |
06d514d7 HS |
211 | } |
212 | efi_free_pool(memmap); | |
213 | ||
214 | return 0; | |
215 | } | |
216 | ||
9cc2323f | 217 | static void lmb_reserve_common(struct lmb *lmb, void *fdt_blob) |
aa3c609e | 218 | { |
aa3c609e SG |
219 | arch_lmb_reserve(lmb); |
220 | board_lmb_reserve(lmb); | |
221 | ||
0c303f9a | 222 | if (CONFIG_IS_ENABLED(OF_LIBFDT) && fdt_blob) |
aa3c609e | 223 | boot_fdt_add_mem_rsv_regions(lmb, fdt_blob); |
06d514d7 HS |
224 | |
225 | if (CONFIG_IS_ENABLED(EFI_LOADER)) | |
226 | efi_lmb_reserve(lmb); | |
aa3c609e SG |
227 | } |
228 | ||
9cc2323f | 229 | /* Initialize the struct, add memory and call arch/board reserve functions */ |
b75d8dc5 | 230 | void lmb_init_and_reserve(struct lmb *lmb, struct bd_info *bd, void *fdt_blob) |
9cc2323f | 231 | { |
9cc2323f | 232 | int i; |
9cc2323f SG |
233 | |
234 | lmb_init(lmb); | |
dfaf6a57 | 235 | |
9cc2323f SG |
236 | for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++) { |
237 | if (bd->bi_dram[i].size) { | |
238 | lmb_add(lmb, bd->bi_dram[i].start, | |
239 | bd->bi_dram[i].size); | |
240 | } | |
241 | } | |
dfaf6a57 | 242 | |
9cc2323f SG |
243 | lmb_reserve_common(lmb, fdt_blob); |
244 | } | |
245 | ||
246 | /* Initialize the struct, add memory and call arch/board reserve functions */ | |
247 | void lmb_init_and_reserve_range(struct lmb *lmb, phys_addr_t base, | |
248 | phys_size_t size, void *fdt_blob) | |
249 | { | |
250 | lmb_init(lmb); | |
251 | lmb_add(lmb, base, size); | |
252 | lmb_reserve_common(lmb, fdt_blob); | |
253 | } | |
254 | ||
4ed6552f | 255 | /* This routine called with relocation disabled. */ |
59c0ea5d PD |
256 | static long lmb_add_region_flags(struct lmb_region *rgn, phys_addr_t base, |
257 | phys_size_t size, enum lmb_flags flags) | |
4ed6552f KG |
258 | { |
259 | unsigned long coalesced = 0; | |
260 | long adjacent, i; | |
261 | ||
d67f33cf | 262 | if (rgn->cnt == 0) { |
4ed6552f KG |
263 | rgn->region[0].base = base; |
264 | rgn->region[0].size = size; | |
59c0ea5d | 265 | rgn->region[0].flags = flags; |
d67f33cf | 266 | rgn->cnt = 1; |
4ed6552f KG |
267 | return 0; |
268 | } | |
269 | ||
270 | /* First try and coalesce this LMB with another. */ | |
e35d2a75 | 271 | for (i = 0; i < rgn->cnt; i++) { |
391fd93a BB |
272 | phys_addr_t rgnbase = rgn->region[i].base; |
273 | phys_size_t rgnsize = rgn->region[i].size; | |
59c0ea5d | 274 | phys_size_t rgnflags = rgn->region[i].flags; |
0d91c882 SS |
275 | phys_addr_t end = base + size - 1; |
276 | phys_addr_t rgnend = rgnbase + rgnsize - 1; | |
0d91c882 | 277 | if (rgnbase <= base && end <= rgnend) { |
59c0ea5d PD |
278 | if (flags == rgnflags) |
279 | /* Already have this region, so we're done */ | |
280 | return 0; | |
281 | else | |
282 | return -1; /* regions with new flags */ | |
283 | } | |
4ed6552f | 284 | |
e35d2a75 SG |
285 | adjacent = lmb_addrs_adjacent(base, size, rgnbase, rgnsize); |
286 | if (adjacent > 0) { | |
59c0ea5d PD |
287 | if (flags != rgnflags) |
288 | break; | |
4ed6552f KG |
289 | rgn->region[i].base -= size; |
290 | rgn->region[i].size += size; | |
291 | coalesced++; | |
292 | break; | |
e35d2a75 | 293 | } else if (adjacent < 0) { |
59c0ea5d PD |
294 | if (flags != rgnflags) |
295 | break; | |
4ed6552f KG |
296 | rgn->region[i].size += size; |
297 | coalesced++; | |
298 | break; | |
0f7c51a6 SG |
299 | } else if (lmb_addrs_overlap(base, size, rgnbase, rgnsize)) { |
300 | /* regions overlap */ | |
301 | return -1; | |
4ed6552f KG |
302 | } |
303 | } | |
304 | ||
edb5824b UK |
305 | if (i < rgn->cnt - 1 && rgn->region[i].flags == rgn->region[i + 1].flags) { |
306 | if (lmb_regions_adjacent(rgn, i, i + 1)) { | |
59c0ea5d PD |
307 | lmb_coalesce_regions(rgn, i, i + 1); |
308 | coalesced++; | |
edb5824b UK |
309 | } else if (lmb_regions_overlap(rgn, i, i + 1)) { |
310 | /* fix overlapping area */ | |
311 | lmb_fix_over_lap_regions(rgn, i, i + 1); | |
312 | coalesced++; | |
59c0ea5d | 313 | } |
4ed6552f KG |
314 | } |
315 | ||
316 | if (coalesced) | |
317 | return coalesced; | |
00fd8dad | 318 | if (rgn->cnt >= rgn->max) |
4ed6552f KG |
319 | return -1; |
320 | ||
321 | /* Couldn't coalesce the LMB, so add it to the sorted table. */ | |
322 | for (i = rgn->cnt-1; i >= 0; i--) { | |
323 | if (base < rgn->region[i].base) { | |
e35d2a75 SG |
324 | rgn->region[i + 1].base = rgn->region[i].base; |
325 | rgn->region[i + 1].size = rgn->region[i].size; | |
59c0ea5d | 326 | rgn->region[i + 1].flags = rgn->region[i].flags; |
4ed6552f | 327 | } else { |
e35d2a75 SG |
328 | rgn->region[i + 1].base = base; |
329 | rgn->region[i + 1].size = size; | |
59c0ea5d | 330 | rgn->region[i + 1].flags = flags; |
4ed6552f KG |
331 | break; |
332 | } | |
333 | } | |
334 | ||
335 | if (base < rgn->region[0].base) { | |
336 | rgn->region[0].base = base; | |
337 | rgn->region[0].size = size; | |
59c0ea5d | 338 | rgn->region[0].flags = flags; |
4ed6552f KG |
339 | } |
340 | ||
341 | rgn->cnt++; | |
342 | ||
343 | return 0; | |
344 | } | |
345 | ||
59c0ea5d PD |
346 | static long lmb_add_region(struct lmb_region *rgn, phys_addr_t base, |
347 | phys_size_t size) | |
348 | { | |
349 | return lmb_add_region_flags(rgn, base, size, LMB_NONE); | |
350 | } | |
351 | ||
4ed6552f | 352 | /* This routine may be called with relocation disabled. */ |
391fd93a | 353 | long lmb_add(struct lmb *lmb, phys_addr_t base, phys_size_t size) |
4ed6552f KG |
354 | { |
355 | struct lmb_region *_rgn = &(lmb->memory); | |
356 | ||
357 | return lmb_add_region(_rgn, base, size); | |
358 | } | |
359 | ||
98874ff3 | 360 | long lmb_free(struct lmb *lmb, phys_addr_t base, phys_size_t size) |
63796c4e AF |
361 | { |
362 | struct lmb_region *rgn = &(lmb->reserved); | |
98874ff3 | 363 | phys_addr_t rgnbegin, rgnend; |
d67f33cf | 364 | phys_addr_t end = base + size - 1; |
63796c4e AF |
365 | int i; |
366 | ||
367 | rgnbegin = rgnend = 0; /* supress gcc warnings */ | |
368 | ||
369 | /* Find the region where (base, size) belongs to */ | |
e35d2a75 | 370 | for (i = 0; i < rgn->cnt; i++) { |
63796c4e | 371 | rgnbegin = rgn->region[i].base; |
d67f33cf | 372 | rgnend = rgnbegin + rgn->region[i].size - 1; |
63796c4e AF |
373 | |
374 | if ((rgnbegin <= base) && (end <= rgnend)) | |
375 | break; | |
376 | } | |
377 | ||
378 | /* Didn't find the region */ | |
379 | if (i == rgn->cnt) | |
380 | return -1; | |
381 | ||
382 | /* Check to see if we are removing entire region */ | |
383 | if ((rgnbegin == base) && (rgnend == end)) { | |
384 | lmb_remove_region(rgn, i); | |
385 | return 0; | |
386 | } | |
387 | ||
388 | /* Check to see if region is matching at the front */ | |
389 | if (rgnbegin == base) { | |
d67f33cf | 390 | rgn->region[i].base = end + 1; |
63796c4e AF |
391 | rgn->region[i].size -= size; |
392 | return 0; | |
393 | } | |
394 | ||
395 | /* Check to see if the region is matching at the end */ | |
396 | if (rgnend == end) { | |
397 | rgn->region[i].size -= size; | |
398 | return 0; | |
399 | } | |
400 | ||
401 | /* | |
402 | * We need to split the entry - adjust the current one to the | |
403 | * beginging of the hole and add the region after hole. | |
404 | */ | |
405 | rgn->region[i].size = base - rgn->region[i].base; | |
59c0ea5d PD |
406 | return lmb_add_region_flags(rgn, end + 1, rgnend - end, |
407 | rgn->region[i].flags); | |
63796c4e AF |
408 | } |
409 | ||
59c0ea5d PD |
410 | long lmb_reserve_flags(struct lmb *lmb, phys_addr_t base, phys_size_t size, |
411 | enum lmb_flags flags) | |
4ed6552f KG |
412 | { |
413 | struct lmb_region *_rgn = &(lmb->reserved); | |
414 | ||
59c0ea5d PD |
415 | return lmb_add_region_flags(_rgn, base, size, flags); |
416 | } | |
417 | ||
418 | long lmb_reserve(struct lmb *lmb, phys_addr_t base, phys_size_t size) | |
419 | { | |
420 | return lmb_reserve_flags(lmb, base, size, LMB_NONE); | |
4ed6552f KG |
421 | } |
422 | ||
750a6ff4 | 423 | static long lmb_overlaps_region(struct lmb_region *rgn, phys_addr_t base, |
391fd93a | 424 | phys_size_t size) |
4ed6552f KG |
425 | { |
426 | unsigned long i; | |
427 | ||
e35d2a75 | 428 | for (i = 0; i < rgn->cnt; i++) { |
391fd93a BB |
429 | phys_addr_t rgnbase = rgn->region[i].base; |
430 | phys_size_t rgnsize = rgn->region[i].size; | |
e35d2a75 | 431 | if (lmb_addrs_overlap(base, size, rgnbase, rgnsize)) |
4ed6552f | 432 | break; |
4ed6552f KG |
433 | } |
434 | ||
435 | return (i < rgn->cnt) ? i : -1; | |
436 | } | |
437 | ||
391fd93a | 438 | phys_addr_t lmb_alloc(struct lmb *lmb, phys_size_t size, ulong align) |
4ed6552f KG |
439 | { |
440 | return lmb_alloc_base(lmb, size, align, LMB_ALLOC_ANYWHERE); | |
441 | } | |
442 | ||
391fd93a | 443 | phys_addr_t lmb_alloc_base(struct lmb *lmb, phys_size_t size, ulong align, phys_addr_t max_addr) |
4ed6552f | 444 | { |
391fd93a | 445 | phys_addr_t alloc; |
4ed6552f KG |
446 | |
447 | alloc = __lmb_alloc_base(lmb, size, align, max_addr); | |
448 | ||
449 | if (alloc == 0) | |
450 | printf("ERROR: Failed to allocate 0x%lx bytes below 0x%lx.\n", | |
e35d2a75 | 451 | (ulong)size, (ulong)max_addr); |
4ed6552f KG |
452 | |
453 | return alloc; | |
454 | } | |
455 | ||
391fd93a | 456 | static phys_addr_t lmb_align_down(phys_addr_t addr, phys_size_t size) |
4ed6552f KG |
457 | { |
458 | return addr & ~(size - 1); | |
459 | } | |
460 | ||
391fd93a | 461 | phys_addr_t __lmb_alloc_base(struct lmb *lmb, phys_size_t size, ulong align, phys_addr_t max_addr) |
4ed6552f | 462 | { |
e35d2a75 | 463 | long i, rgn; |
391fd93a | 464 | phys_addr_t base = 0; |
7570a994 | 465 | phys_addr_t res_base; |
4ed6552f | 466 | |
e35d2a75 | 467 | for (i = lmb->memory.cnt - 1; i >= 0; i--) { |
391fd93a BB |
468 | phys_addr_t lmbbase = lmb->memory.region[i].base; |
469 | phys_size_t lmbsize = lmb->memory.region[i].size; | |
4ed6552f | 470 | |
7570a994 AF |
471 | if (lmbsize < size) |
472 | continue; | |
4ed6552f KG |
473 | if (max_addr == LMB_ALLOC_ANYWHERE) |
474 | base = lmb_align_down(lmbbase + lmbsize - size, align); | |
475 | else if (lmbbase < max_addr) { | |
ad3fda52 SW |
476 | base = lmbbase + lmbsize; |
477 | if (base < lmbbase) | |
478 | base = -1; | |
479 | base = min(base, max_addr); | |
4ed6552f KG |
480 | base = lmb_align_down(base - size, align); |
481 | } else | |
482 | continue; | |
483 | ||
7570a994 | 484 | while (base && lmbbase <= base) { |
e35d2a75 SG |
485 | rgn = lmb_overlaps_region(&lmb->reserved, base, size); |
486 | if (rgn < 0) { | |
7570a994 AF |
487 | /* This area isn't reserved, take it */ |
488 | if (lmb_add_region(&lmb->reserved, base, | |
0f7c51a6 | 489 | size) < 0) |
7570a994 AF |
490 | return 0; |
491 | return base; | |
492 | } | |
e35d2a75 | 493 | res_base = lmb->reserved.region[rgn].base; |
7570a994 AF |
494 | if (res_base < size) |
495 | break; | |
496 | base = lmb_align_down(res_base - size, align); | |
497 | } | |
4ed6552f | 498 | } |
7570a994 | 499 | return 0; |
4ed6552f KG |
500 | } |
501 | ||
4cc8af80 SG |
502 | /* |
503 | * Try to allocate a specific address range: must be in defined memory but not | |
504 | * reserved | |
505 | */ | |
506 | phys_addr_t lmb_alloc_addr(struct lmb *lmb, phys_addr_t base, phys_size_t size) | |
507 | { | |
e35d2a75 | 508 | long rgn; |
4cc8af80 SG |
509 | |
510 | /* Check if the requested address is in one of the memory regions */ | |
e35d2a75 SG |
511 | rgn = lmb_overlaps_region(&lmb->memory, base, size); |
512 | if (rgn >= 0) { | |
4cc8af80 SG |
513 | /* |
514 | * Check if the requested end address is in the same memory | |
515 | * region we found. | |
516 | */ | |
e35d2a75 SG |
517 | if (lmb_addrs_overlap(lmb->memory.region[rgn].base, |
518 | lmb->memory.region[rgn].size, | |
519 | base + size - 1, 1)) { | |
4cc8af80 SG |
520 | /* ok, reserve the memory */ |
521 | if (lmb_reserve(lmb, base, size) >= 0) | |
522 | return base; | |
523 | } | |
524 | } | |
525 | return 0; | |
526 | } | |
527 | ||
528 | /* Return number of bytes from a given address that are free */ | |
65304aad | 529 | phys_size_t lmb_get_free_size(struct lmb *lmb, phys_addr_t addr) |
4cc8af80 SG |
530 | { |
531 | int i; | |
e35d2a75 | 532 | long rgn; |
4cc8af80 SG |
533 | |
534 | /* check if the requested address is in the memory regions */ | |
e35d2a75 SG |
535 | rgn = lmb_overlaps_region(&lmb->memory, addr, 1); |
536 | if (rgn >= 0) { | |
4cc8af80 SG |
537 | for (i = 0; i < lmb->reserved.cnt; i++) { |
538 | if (addr < lmb->reserved.region[i].base) { | |
539 | /* first reserved range > requested address */ | |
540 | return lmb->reserved.region[i].base - addr; | |
541 | } | |
542 | if (lmb->reserved.region[i].base + | |
543 | lmb->reserved.region[i].size > addr) { | |
544 | /* requested addr is in this reserved range */ | |
545 | return 0; | |
546 | } | |
547 | } | |
548 | /* if we come here: no reserved ranges above requested addr */ | |
549 | return lmb->memory.region[lmb->memory.cnt - 1].base + | |
550 | lmb->memory.region[lmb->memory.cnt - 1].size - addr; | |
551 | } | |
552 | return 0; | |
553 | } | |
554 | ||
e359a4a5 | 555 | int lmb_is_reserved_flags(struct lmb *lmb, phys_addr_t addr, int flags) |
4ed6552f KG |
556 | { |
557 | int i; | |
558 | ||
559 | for (i = 0; i < lmb->reserved.cnt; i++) { | |
391fd93a | 560 | phys_addr_t upper = lmb->reserved.region[i].base + |
4ed6552f KG |
561 | lmb->reserved.region[i].size - 1; |
562 | if ((addr >= lmb->reserved.region[i].base) && (addr <= upper)) | |
e359a4a5 | 563 | return (lmb->reserved.region[i].flags & flags) == flags; |
4ed6552f KG |
564 | } |
565 | return 0; | |
566 | } | |
a16028da | 567 | |
e359a4a5 PD |
568 | int lmb_is_reserved(struct lmb *lmb, phys_addr_t addr) |
569 | { | |
570 | return lmb_is_reserved_flags(lmb, addr, LMB_NONE); | |
571 | } | |
572 | ||
2c34f3f5 | 573 | __weak void board_lmb_reserve(struct lmb *lmb) |
a16028da MF |
574 | { |
575 | /* please define platform specific board_lmb_reserve() */ | |
576 | } | |
a16028da | 577 | |
2c34f3f5 | 578 | __weak void arch_lmb_reserve(struct lmb *lmb) |
a16028da MF |
579 | { |
580 | /* please define platform specific arch_lmb_reserve() */ | |
581 | } |