blob: b03237bc06cba1919e2b88800076adaf22536061 [file] [log] [blame]
Tom Rini10e47792018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Kumar Gala6d7bfa82008-02-27 21:51:47 -06002/*
3 * Procedures for maintaining information about logical memory blocks.
4 *
5 * Peter Bergner, IBM Corp. June 2001.
6 * Copyright (C) 2001 Peter Bergner.
Kumar Gala6d7bfa82008-02-27 21:51:47 -06007 */
8
Sughosh Ganu291bf9c2024-08-26 17:29:18 +05309#include <alist.h>
Heinrich Schuchardtc9bb2eb2023-01-04 01:36:14 +010010#include <efi_loader.h>
Sughosh Ganua3af5ba2024-10-15 21:07:07 +053011#include <event.h>
Simon Glass2dc9c342020-05-10 11:40:01 -060012#include <image.h>
Heinrich Schuchardtc9bb2eb2023-01-04 01:36:14 +010013#include <mapmem.h>
Kumar Gala6d7bfa82008-02-27 21:51:47 -060014#include <lmb.h>
Simon Glass0f2af882020-05-10 11:40:05 -060015#include <log.h>
Simon Glass9bc15642020-02-03 07:36:16 -070016#include <malloc.h>
Sughosh Ganu6518b412024-08-26 17:29:24 +053017#include <spl.h>
Kumar Gala6d7bfa82008-02-27 21:51:47 -060018
Marek Vasuta2eec022021-09-10 22:47:09 +020019#include <asm/global_data.h>
Marek Vasut0fcae7f2021-11-13 18:34:37 +010020#include <asm/sections.h>
Sughosh Ganu291bf9c2024-08-26 17:29:18 +053021#include <linux/kernel.h>
Sughosh Ganue5348c72024-08-26 17:29:30 +053022#include <linux/sizes.h>
Marek Vasuta2eec022021-09-10 22:47:09 +020023
24DECLARE_GLOBAL_DATA_PTR;
25
Sughosh Ganua3af5ba2024-10-15 21:07:07 +053026#define MAP_OP_RESERVE (u8)0x1
27#define MAP_OP_FREE (u8)0x2
28#define MAP_OP_ADD (u8)0x3
29
Janne Grunau5631f442024-11-11 07:56:32 +010030/*
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 */
Kumar Gala6d7bfa82008-02-27 21:51:47 -060035
Simon Goldschmidtf41f7d62019-01-21 20:29:56 +010036static long lmb_addrs_overlap(phys_addr_t base1, phys_size_t size1,
37 phys_addr_t base2, phys_size_t size2)
Kumar Gala6d7bfa82008-02-27 21:51:47 -060038{
Simon Goldschmidt6402d9b2019-01-14 22:38:15 +010039 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));
Kumar Gala6d7bfa82008-02-27 21:51:47 -060043}
44
Becky Bruced26d67c2008-06-09 20:37:18 -050045static long lmb_addrs_adjacent(phys_addr_t base1, phys_size_t size1,
Simon Goldschmidtf41f7d62019-01-21 20:29:56 +010046 phys_addr_t base2, phys_size_t size2)
Kumar Gala6d7bfa82008-02-27 21:51:47 -060047{
48 if (base2 == base1 + size1)
49 return 1;
50 else if (base1 == base2 + size2)
51 return -1;
52
53 return 0;
54}
55
Sughosh Ganu291bf9c2024-08-26 17:29:18 +053056static long lmb_regions_overlap(struct alist *lmb_rgn_lst, unsigned long r1,
Udit Kumar4e8e6632023-09-26 16:54:42 +053057 unsigned long r2)
58{
Sughosh Ganu291bf9c2024-08-26 17:29:18 +053059 struct lmb_region *rgn = lmb_rgn_lst->data;
60
61 phys_addr_t base1 = rgn[r1].base;
62 phys_size_t size1 = rgn[r1].size;
63 phys_addr_t base2 = rgn[r2].base;
64 phys_size_t size2 = rgn[r2].size;
Udit Kumar4e8e6632023-09-26 16:54:42 +053065
66 return lmb_addrs_overlap(base1, size1, base2, size2);
67}
Sughosh Ganu291bf9c2024-08-26 17:29:18 +053068
69static long lmb_regions_adjacent(struct alist *lmb_rgn_lst, unsigned long r1,
Simon Goldschmidtf41f7d62019-01-21 20:29:56 +010070 unsigned long r2)
Kumar Gala6d7bfa82008-02-27 21:51:47 -060071{
Sughosh Ganu291bf9c2024-08-26 17:29:18 +053072 struct lmb_region *rgn = lmb_rgn_lst->data;
73
74 phys_addr_t base1 = rgn[r1].base;
75 phys_size_t size1 = rgn[r1].size;
76 phys_addr_t base2 = rgn[r2].base;
77 phys_size_t size2 = rgn[r2].size;
Kumar Gala6d7bfa82008-02-27 21:51:47 -060078 return lmb_addrs_adjacent(base1, size1, base2, size2);
79}
80
Sughosh Ganu291bf9c2024-08-26 17:29:18 +053081static void lmb_remove_region(struct alist *lmb_rgn_lst, unsigned long r)
Kumar Gala6d7bfa82008-02-27 21:51:47 -060082{
83 unsigned long i;
Sughosh Ganu291bf9c2024-08-26 17:29:18 +053084 struct lmb_region *rgn = lmb_rgn_lst->data;
Kumar Gala6d7bfa82008-02-27 21:51:47 -060085
Sughosh Ganu291bf9c2024-08-26 17:29:18 +053086 for (i = r; i < lmb_rgn_lst->count - 1; i++) {
87 rgn[i].base = rgn[i + 1].base;
88 rgn[i].size = rgn[i + 1].size;
89 rgn[i].flags = rgn[i + 1].flags;
Kumar Gala6d7bfa82008-02-27 21:51:47 -060090 }
Sughosh Ganu291bf9c2024-08-26 17:29:18 +053091 lmb_rgn_lst->count--;
Kumar Gala6d7bfa82008-02-27 21:51:47 -060092}
93
94/* Assumption: base addr of region 1 < base addr of region 2 */
Sughosh Ganu291bf9c2024-08-26 17:29:18 +053095static void lmb_coalesce_regions(struct alist *lmb_rgn_lst, unsigned long r1,
Simon Goldschmidtf41f7d62019-01-21 20:29:56 +010096 unsigned long r2)
Kumar Gala6d7bfa82008-02-27 21:51:47 -060097{
Sughosh Ganu291bf9c2024-08-26 17:29:18 +053098 struct lmb_region *rgn = lmb_rgn_lst->data;
99
100 rgn[r1].size += rgn[r2].size;
101 lmb_remove_region(lmb_rgn_lst, r2);
Kumar Gala6d7bfa82008-02-27 21:51:47 -0600102}
103
Udit Kumar4e8e6632023-09-26 16:54:42 +0530104/*Assumption : base addr of region 1 < base addr of region 2*/
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530105static void lmb_fix_over_lap_regions(struct alist *lmb_rgn_lst,
106 unsigned long r1, unsigned long r2)
Udit Kumar4e8e6632023-09-26 16:54:42 +0530107{
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530108 struct lmb_region *rgn = lmb_rgn_lst->data;
109
110 phys_addr_t base1 = rgn[r1].base;
111 phys_size_t size1 = rgn[r1].size;
112 phys_addr_t base2 = rgn[r2].base;
113 phys_size_t size2 = rgn[r2].size;
Udit Kumar4e8e6632023-09-26 16:54:42 +0530114
115 if (base1 + size1 > base2 + size2) {
116 printf("This will not be a case any time\n");
117 return;
118 }
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530119 rgn[r1].size = base2 + size2 - base1;
120 lmb_remove_region(lmb_rgn_lst, r2);
Udit Kumar4e8e6632023-09-26 16:54:42 +0530121}
122
Sughosh Ganu50e27272024-08-26 17:29:19 +0530123static long lmb_resize_regions(struct alist *lmb_rgn_lst,
124 unsigned long idx_start,
125 phys_addr_t base, phys_size_t size)
126{
127 phys_size_t rgnsize;
128 unsigned long rgn_cnt, idx, idx_end;
129 phys_addr_t rgnbase, rgnend;
130 phys_addr_t mergebase, mergeend;
131 struct lmb_region *rgn = lmb_rgn_lst->data;
132
133 rgn_cnt = 0;
134 idx = idx_start;
135 idx_end = idx_start;
136
137 /*
138 * First thing to do is to identify how many regions
139 * the requested region overlaps.
140 * If the flags match, combine all these overlapping
141 * regions into a single region, and remove the merged
142 * regions.
143 */
144 while (idx <= lmb_rgn_lst->count - 1) {
145 rgnbase = rgn[idx].base;
146 rgnsize = rgn[idx].size;
147
148 if (lmb_addrs_overlap(base, size, rgnbase,
149 rgnsize)) {
150 if (rgn[idx].flags != LMB_NONE)
151 return -1;
152 rgn_cnt++;
153 idx_end = idx;
154 }
155 idx++;
156 }
157
158 /* The merged region's base and size */
159 rgnbase = rgn[idx_start].base;
160 mergebase = min(base, rgnbase);
161 rgnend = rgn[idx_end].base + rgn[idx_end].size;
162 mergeend = max(rgnend, (base + size));
163
164 rgn[idx_start].base = mergebase;
165 rgn[idx_start].size = mergeend - mergebase;
166
167 /* Now remove the merged regions */
168 while (--rgn_cnt)
169 lmb_remove_region(lmb_rgn_lst, idx_start + 1);
170
171 return 0;
172}
173
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530174/**
175 * lmb_add_region_flags() - Add an lmb region to the given list
176 * @lmb_rgn_lst: LMB list to which region is to be added(free/used)
177 * @base: Start address of the region
178 * @size: Size of the region to be added
179 * @flags: Attributes of the LMB region
180 *
181 * Add a region of memory to the list. If the region does not exist, add
182 * it to the list. Depending on the attributes of the region to be added,
183 * the function might resize an already existing region or coalesce two
184 * adjacent regions.
185 *
186 *
187 * Returns: 0 if the region addition successful, -1 on failure
188 */
189static long lmb_add_region_flags(struct alist *lmb_rgn_lst, phys_addr_t base,
Patrick Delaunaye11c9082021-05-07 14:50:29 +0200190 phys_size_t size, enum lmb_flags flags)
Kumar Gala6d7bfa82008-02-27 21:51:47 -0600191{
192 unsigned long coalesced = 0;
Sughosh Ganu50e27272024-08-26 17:29:19 +0530193 long ret, i;
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530194 struct lmb_region *rgn = lmb_rgn_lst->data;
Kumar Gala6d7bfa82008-02-27 21:51:47 -0600195
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530196 if (alist_err(lmb_rgn_lst))
197 return -1;
Kumar Gala6d7bfa82008-02-27 21:51:47 -0600198
199 /* First try and coalesce this LMB with another. */
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530200 for (i = 0; i < lmb_rgn_lst->count; i++) {
201 phys_addr_t rgnbase = rgn[i].base;
202 phys_size_t rgnsize = rgn[i].size;
203 phys_size_t rgnflags = rgn[i].flags;
Kumar Gala6d7bfa82008-02-27 21:51:47 -0600204
Sughosh Ganu50e27272024-08-26 17:29:19 +0530205 ret = lmb_addrs_adjacent(base, size, rgnbase, rgnsize);
206 if (ret > 0) {
Patrick Delaunaye11c9082021-05-07 14:50:29 +0200207 if (flags != rgnflags)
208 break;
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530209 rgn[i].base -= size;
210 rgn[i].size += size;
Kumar Gala6d7bfa82008-02-27 21:51:47 -0600211 coalesced++;
212 break;
Sughosh Ganu50e27272024-08-26 17:29:19 +0530213 } else if (ret < 0) {
Patrick Delaunaye11c9082021-05-07 14:50:29 +0200214 if (flags != rgnflags)
215 break;
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530216 rgn[i].size += size;
Kumar Gala6d7bfa82008-02-27 21:51:47 -0600217 coalesced++;
218 break;
Simon Goldschmidtcb57d132019-01-14 22:38:16 +0100219 } else if (lmb_addrs_overlap(base, size, rgnbase, rgnsize)) {
Sughosh Ganu50e27272024-08-26 17:29:19 +0530220 if (flags == LMB_NONE) {
221 ret = lmb_resize_regions(lmb_rgn_lst, i, base,
222 size);
223 if (ret < 0)
224 return -1;
225
226 coalesced++;
227 break;
228 } else {
229 return -1;
230 }
Kumar Gala6d7bfa82008-02-27 21:51:47 -0600231 }
232 }
233
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530234 if (lmb_rgn_lst->count && i < lmb_rgn_lst->count - 1) {
235 rgn = lmb_rgn_lst->data;
236 if (rgn[i].flags == rgn[i + 1].flags) {
237 if (lmb_regions_adjacent(lmb_rgn_lst, i, i + 1)) {
238 lmb_coalesce_regions(lmb_rgn_lst, i, i + 1);
239 coalesced++;
240 } else if (lmb_regions_overlap(lmb_rgn_lst, i, i + 1)) {
241 /* fix overlapping area */
242 lmb_fix_over_lap_regions(lmb_rgn_lst, i, i + 1);
243 coalesced++;
244 }
Patrick Delaunaye11c9082021-05-07 14:50:29 +0200245 }
Kumar Gala6d7bfa82008-02-27 21:51:47 -0600246 }
247
248 if (coalesced)
Ilias Apalodimas98491252024-10-23 18:22:00 +0300249 return 0;
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530250
251 if (alist_full(lmb_rgn_lst) &&
252 !alist_expand_by(lmb_rgn_lst, lmb_rgn_lst->alloc))
Kumar Gala6d7bfa82008-02-27 21:51:47 -0600253 return -1;
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530254 rgn = lmb_rgn_lst->data;
Kumar Gala6d7bfa82008-02-27 21:51:47 -0600255
256 /* Couldn't coalesce the LMB, so add it to the sorted table. */
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530257 for (i = lmb_rgn_lst->count; i >= 0; i--) {
258 if (i && base < rgn[i - 1].base) {
259 rgn[i] = rgn[i - 1];
Kumar Gala6d7bfa82008-02-27 21:51:47 -0600260 } else {
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530261 rgn[i].base = base;
262 rgn[i].size = size;
263 rgn[i].flags = flags;
Kumar Gala6d7bfa82008-02-27 21:51:47 -0600264 break;
265 }
266 }
267
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530268 lmb_rgn_lst->count++;
Kumar Gala6d7bfa82008-02-27 21:51:47 -0600269
270 return 0;
271}
272
Janne Grunaud9c70402024-11-11 07:56:31 +0100273static long _lmb_free(struct alist *lmb_rgn_lst, phys_addr_t base,
274 phys_size_t size)
Andy Fleming1ae346c2008-06-16 13:58:54 -0500275{
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530276 struct lmb_region *rgn;
Andy Fleming09d2a712008-07-07 14:24:39 -0500277 phys_addr_t rgnbegin, rgnend;
Simon Goldschmidt6402d9b2019-01-14 22:38:15 +0100278 phys_addr_t end = base + size - 1;
Andy Fleming1ae346c2008-06-16 13:58:54 -0500279 int i;
280
281 rgnbegin = rgnend = 0; /* supress gcc warnings */
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530282 rgn = lmb_rgn_lst->data;
Andy Fleming1ae346c2008-06-16 13:58:54 -0500283 /* Find the region where (base, size) belongs to */
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530284 for (i = 0; i < lmb_rgn_lst->count; i++) {
285 rgnbegin = rgn[i].base;
286 rgnend = rgnbegin + rgn[i].size - 1;
Andy Fleming1ae346c2008-06-16 13:58:54 -0500287
288 if ((rgnbegin <= base) && (end <= rgnend))
289 break;
290 }
291
292 /* Didn't find the region */
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530293 if (i == lmb_rgn_lst->count)
Andy Fleming1ae346c2008-06-16 13:58:54 -0500294 return -1;
295
296 /* Check to see if we are removing entire region */
297 if ((rgnbegin == base) && (rgnend == end)) {
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530298 lmb_remove_region(lmb_rgn_lst, i);
Andy Fleming1ae346c2008-06-16 13:58:54 -0500299 return 0;
300 }
301
302 /* Check to see if region is matching at the front */
303 if (rgnbegin == base) {
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530304 rgn[i].base = end + 1;
305 rgn[i].size -= size;
Andy Fleming1ae346c2008-06-16 13:58:54 -0500306 return 0;
307 }
308
309 /* Check to see if the region is matching at the end */
310 if (rgnend == end) {
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530311 rgn[i].size -= size;
Andy Fleming1ae346c2008-06-16 13:58:54 -0500312 return 0;
313 }
314
315 /*
316 * We need to split the entry - adjust the current one to the
317 * beginging of the hole and add the region after hole.
318 */
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530319 rgn[i].size = base - rgn[i].base;
320 return lmb_add_region_flags(lmb_rgn_lst, end + 1, rgnend - end,
321 rgn[i].flags);
Andy Fleming1ae346c2008-06-16 13:58:54 -0500322}
323
Janne Grunau5631f442024-11-11 07:56:32 +0100324static long lmb_overlaps_region(struct alist *lmb_rgn_lst, phys_addr_t base,
325 phys_size_t size)
326{
327 unsigned long i;
328 struct lmb_region *rgn = lmb_rgn_lst->data;
329
330 for (i = 0; i < lmb_rgn_lst->count; i++) {
331 phys_addr_t rgnbase = rgn[i].base;
332 phys_size_t rgnsize = rgn[i].size;
333 if (lmb_addrs_overlap(base, size, rgnbase, rgnsize))
334 break;
335 }
336
337 return (i < lmb_rgn_lst->count) ? i : -1;
338}
339
340static phys_addr_t lmb_align_down(phys_addr_t addr, phys_size_t size)
341{
342 return addr & ~(size - 1);
343}
344
345/*
Janne Grunaue818d3c2024-11-11 07:56:33 +0100346 * 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->free_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->free_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->free_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->free_mem.data;
391
392 for (i = io_lmb->free_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 = lmb_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 = lmb_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/*
Janne Grunau5631f442024-11-11 07:56:32 +0100426 * 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(enum lmb_flags 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 enum lmb_flags 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(enum lmb_flags flags)
474{
Janne Grunau5631f442024-11-11 07:56:32 +0100475 const char *flag_str[] = { "none", "no-map", "no-overwrite", "no-notify" };
Heinrich Schuchardt55738202024-11-02 07:32:26 +0100476 unsigned int pflags = flags &
477 (LMB_NOMAP | LMB_NOOVERWRITE | LMB_NONOTIFY);
478
479 if (flags != pflags) {
480 printf("invalid %#x\n", flags);
481 return;
482 }
Janne Grunau5631f442024-11-11 07:56:32 +0100483
484 do {
Heinrich Schuchardt55738202024-11-02 07:32:26 +0100485 int bitpos = pflags ? fls(pflags) - 1 : 0;
486
Janne Grunau5631f442024-11-11 07:56:32 +0100487 printf("%s", flag_str[bitpos]);
Heinrich Schuchardt55738202024-11-02 07:32:26 +0100488 pflags &= ~(1u << bitpos);
489 puts(pflags ? ", " : "\n");
490 } while (pflags);
Janne Grunau5631f442024-11-11 07:56:32 +0100491}
492
493static void lmb_dump_region(struct alist *lmb_rgn_lst, char *name)
494{
495 struct lmb_region *rgn = lmb_rgn_lst->data;
496 unsigned long long base, size, end;
497 enum lmb_flags flags;
498 int i;
499
Heinrich Schuchardt2abe3052024-11-07 11:14:42 +0100500 printf(" %s.count = %#x\n", name, lmb_rgn_lst->count);
Janne Grunau5631f442024-11-11 07:56:32 +0100501
502 for (i = 0; i < lmb_rgn_lst->count; i++) {
503 base = rgn[i].base;
504 size = rgn[i].size;
505 end = base + size - 1;
506 flags = rgn[i].flags;
507
Heinrich Schuchardt2abe3052024-11-07 11:14:42 +0100508 printf(" %s[%d]\t[%#llx-%#llx], %#llx bytes, flags: ",
Janne Grunau5631f442024-11-11 07:56:32 +0100509 name, i, base, end, size);
510 lmb_print_region_flags(flags);
511 }
512}
513
514void lmb_dump_all_force(void)
515{
516 printf("lmb_dump_all:\n");
517 lmb_dump_region(&lmb.free_mem, "memory");
518 lmb_dump_region(&lmb.used_mem, "reserved");
519}
520
521void lmb_dump_all(void)
522{
523#ifdef DEBUG
524 lmb_dump_all_force();
525#endif
526}
527
528static void lmb_reserve_uboot_region(void)
529{
530 int bank;
531 ulong end, bank_end;
532 phys_addr_t rsv_start;
533
534 rsv_start = gd->start_addr_sp - CONFIG_STACK_SIZE;
535 end = gd->ram_top;
536
537 /*
538 * Reserve memory from aligned address below the bottom of U-Boot stack
539 * until end of RAM area to prevent LMB from overwriting that memory.
540 */
541 debug("## Current stack ends at 0x%08lx ", (ulong)rsv_start);
542
543 for (bank = 0; bank < CONFIG_NR_DRAM_BANKS; bank++) {
544 if (!gd->bd->bi_dram[bank].size ||
545 rsv_start < gd->bd->bi_dram[bank].start)
546 continue;
547 /* Watch out for RAM at end of address space! */
548 bank_end = gd->bd->bi_dram[bank].start +
549 gd->bd->bi_dram[bank].size - 1;
550 if (rsv_start > bank_end)
551 continue;
552 if (bank_end > end)
553 bank_end = end - 1;
554
555 lmb_reserve_flags(rsv_start, bank_end - rsv_start + 1,
556 LMB_NOOVERWRITE);
557
558 if (gd->flags & GD_FLG_SKIP_RELOC)
559 lmb_reserve_flags((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_flags(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_flags(rsv_start, rsv_size, LMB_NOOVERWRITE);
595 }
596}
597
598/**
599 * lmb_add_memory() - Add memory range for LMB allocations
600 *
601 * Add the entire available memory range to the pool of memory that
602 * can be used by the LMB module for allocations.
603 *
604 * Return: None
605 */
606void lmb_add_memory(void)
607{
608 int i;
Sughosh Ganued220b82024-12-02 12:36:24 +0530609 phys_addr_t bank_end;
Janne Grunau5631f442024-11-11 07:56:32 +0100610 phys_size_t size;
611 u64 ram_top = gd->ram_top;
612 struct bd_info *bd = gd->bd;
613
614 if (CONFIG_IS_ENABLED(LMB_ARCH_MEM_MAP))
615 return lmb_arch_add_memory();
616
617 /* Assume a 4GB ram_top if not defined */
618 if (!ram_top)
619 ram_top = 0x100000000ULL;
620
621 for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++) {
622 size = bd->bi_dram[i].size;
Sughosh Ganued220b82024-12-02 12:36:24 +0530623 bank_end = bd->bi_dram[i].start + size;
624
Janne Grunau5631f442024-11-11 07:56:32 +0100625 if (size) {
626 lmb_add(bd->bi_dram[i].start, size);
627
628 /*
629 * Reserve memory above ram_top as
630 * no-overwrite so that it cannot be
631 * allocated
632 */
633 if (bd->bi_dram[i].start >= ram_top)
634 lmb_reserve_flags(bd->bi_dram[i].start, size,
635 LMB_NOOVERWRITE);
Sughosh Ganued220b82024-12-02 12:36:24 +0530636 else if (bank_end > ram_top)
637 lmb_reserve_flags(ram_top, bank_end - ram_top,
638 LMB_NOOVERWRITE);
Janne Grunau5631f442024-11-11 07:56:32 +0100639 }
640 }
641}
642
643static long lmb_add_region(struct alist *lmb_rgn_lst, phys_addr_t base,
644 phys_size_t size)
645{
646 return lmb_add_region_flags(lmb_rgn_lst, base, size, LMB_NONE);
647}
648
649/* This routine may be called with relocation disabled. */
650long lmb_add(phys_addr_t base, phys_size_t size)
651{
652 long ret;
653 struct alist *lmb_rgn_lst = &lmb.free_mem;
654
655 ret = lmb_add_region(lmb_rgn_lst, base, size);
656 if (ret)
657 return ret;
658
659 return lmb_map_update_notify(base, size, MAP_OP_ADD, LMB_NONE);
660}
661
Sughosh Ganu7f15d322024-10-15 21:07:03 +0530662/**
663 * lmb_free_flags() - Free up a region of memory
664 * @base: Base Address of region to be freed
665 * @size: Size of the region to be freed
666 * @flags: Memory region attributes
667 *
668 * Free up a region of memory.
669 *
670 * Return: 0 if successful, -1 on failure
671 */
672long lmb_free_flags(phys_addr_t base, phys_size_t size,
Sughosh Ganua3af5ba2024-10-15 21:07:07 +0530673 uint flags)
Sughosh Ganu7f15d322024-10-15 21:07:03 +0530674{
Sughosh Ganua3af5ba2024-10-15 21:07:07 +0530675 long ret;
676
Janne Grunaud9c70402024-11-11 07:56:31 +0100677 ret = _lmb_free(&lmb.used_mem, base, size);
Sughosh Ganua3af5ba2024-10-15 21:07:07 +0530678 if (ret < 0)
679 return ret;
680
Ilias Apalodimas2930f892024-10-23 18:22:01 +0300681 return lmb_map_update_notify(base, size, MAP_OP_FREE, flags);
Sughosh Ganu7f15d322024-10-15 21:07:03 +0530682}
683
Sughosh Ganua3af5ba2024-10-15 21:07:07 +0530684long lmb_free(phys_addr_t base, phys_size_t size)
685{
686 return lmb_free_flags(base, size, LMB_NONE);
687}
688
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530689long lmb_reserve_flags(phys_addr_t base, phys_size_t size, enum lmb_flags flags)
Kumar Gala6d7bfa82008-02-27 21:51:47 -0600690{
Sughosh Ganua3af5ba2024-10-15 21:07:07 +0530691 long ret = 0;
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530692 struct alist *lmb_rgn_lst = &lmb.used_mem;
Kumar Gala6d7bfa82008-02-27 21:51:47 -0600693
Sughosh Ganua3af5ba2024-10-15 21:07:07 +0530694 ret = lmb_add_region_flags(lmb_rgn_lst, base, size, flags);
Ilias Apalodimas98491252024-10-23 18:22:00 +0300695 if (ret)
696 return ret;
Sughosh Ganua3af5ba2024-10-15 21:07:07 +0530697
Ilias Apalodimas2930f892024-10-23 18:22:01 +0300698 return lmb_map_update_notify(base, size, MAP_OP_RESERVE, flags);
Patrick Delaunaye11c9082021-05-07 14:50:29 +0200699}
700
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530701long lmb_reserve(phys_addr_t base, phys_size_t size)
Patrick Delaunaye11c9082021-05-07 14:50:29 +0200702{
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530703 return lmb_reserve_flags(base, size, LMB_NONE);
Kumar Gala6d7bfa82008-02-27 21:51:47 -0600704}
705
Sughosh Ganu99b59662024-10-15 21:07:17 +0530706static phys_addr_t _lmb_alloc_base(phys_size_t size, ulong align,
Sughosh Ganu50e27272024-08-26 17:29:19 +0530707 phys_addr_t max_addr, enum lmb_flags flags)
Kumar Gala6d7bfa82008-02-27 21:51:47 -0600708{
Sughosh Ganua3af5ba2024-10-15 21:07:07 +0530709 int ret;
Simon Goldschmidtf41f7d62019-01-21 20:29:56 +0100710 long i, rgn;
Becky Bruced26d67c2008-06-09 20:37:18 -0500711 phys_addr_t base = 0;
Andy Fleming78bd5a72008-06-16 13:58:55 -0500712 phys_addr_t res_base;
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530713 struct lmb_region *lmb_used = lmb.used_mem.data;
714 struct lmb_region *lmb_memory = lmb.free_mem.data;
Kumar Gala6d7bfa82008-02-27 21:51:47 -0600715
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530716 for (i = lmb.free_mem.count - 1; i >= 0; i--) {
717 phys_addr_t lmbbase = lmb_memory[i].base;
718 phys_size_t lmbsize = lmb_memory[i].size;
Kumar Gala6d7bfa82008-02-27 21:51:47 -0600719
Andy Fleming78bd5a72008-06-16 13:58:55 -0500720 if (lmbsize < size)
721 continue;
Kumar Gala6d7bfa82008-02-27 21:51:47 -0600722 if (max_addr == LMB_ALLOC_ANYWHERE)
723 base = lmb_align_down(lmbbase + lmbsize - size, align);
724 else if (lmbbase < max_addr) {
Stephen Warrenb6a010b2014-07-31 13:40:07 -0600725 base = lmbbase + lmbsize;
726 if (base < lmbbase)
727 base = -1;
728 base = min(base, max_addr);
Kumar Gala6d7bfa82008-02-27 21:51:47 -0600729 base = lmb_align_down(base - size, align);
730 } else
731 continue;
732
Andy Fleming78bd5a72008-06-16 13:58:55 -0500733 while (base && lmbbase <= base) {
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530734 rgn = lmb_overlaps_region(&lmb.used_mem, base, size);
Simon Goldschmidtf41f7d62019-01-21 20:29:56 +0100735 if (rgn < 0) {
Andy Fleming78bd5a72008-06-16 13:58:55 -0500736 /* This area isn't reserved, take it */
Sughosh Ganu50e27272024-08-26 17:29:19 +0530737 if (lmb_add_region_flags(&lmb.used_mem, base,
Ilias Apalodimas98491252024-10-23 18:22:00 +0300738 size, flags))
Andy Fleming78bd5a72008-06-16 13:58:55 -0500739 return 0;
Sughosh Ganua3af5ba2024-10-15 21:07:07 +0530740
Ilias Apalodimas2930f892024-10-23 18:22:01 +0300741 ret = lmb_map_update_notify(base, size,
742 MAP_OP_RESERVE,
743 flags);
744 if (ret)
745 return ret;
Sughosh Ganua3af5ba2024-10-15 21:07:07 +0530746
Andy Fleming78bd5a72008-06-16 13:58:55 -0500747 return base;
748 }
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530749
750 res_base = lmb_used[rgn].base;
Andy Fleming78bd5a72008-06-16 13:58:55 -0500751 if (res_base < size)
752 break;
753 base = lmb_align_down(res_base - size, align);
754 }
Kumar Gala6d7bfa82008-02-27 21:51:47 -0600755 }
Andy Fleming78bd5a72008-06-16 13:58:55 -0500756 return 0;
Kumar Gala6d7bfa82008-02-27 21:51:47 -0600757}
758
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530759phys_addr_t lmb_alloc(phys_size_t size, ulong align)
Sughosh Ganu78435de2024-08-26 17:29:16 +0530760{
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530761 return lmb_alloc_base(size, align, LMB_ALLOC_ANYWHERE);
Sughosh Ganu78435de2024-08-26 17:29:16 +0530762}
763
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530764phys_addr_t lmb_alloc_base(phys_size_t size, ulong align, phys_addr_t max_addr)
Sughosh Ganu78435de2024-08-26 17:29:16 +0530765{
766 phys_addr_t alloc;
767
Sughosh Ganu99b59662024-10-15 21:07:17 +0530768 alloc = _lmb_alloc_base(size, align, max_addr, LMB_NONE);
Sughosh Ganu78435de2024-08-26 17:29:16 +0530769
770 if (alloc == 0)
771 printf("ERROR: Failed to allocate 0x%lx bytes below 0x%lx.\n",
772 (ulong)size, (ulong)max_addr);
773
774 return alloc;
775}
776
Sughosh Ganu7f15d322024-10-15 21:07:03 +0530777/**
778 * lmb_alloc_base_flags() - Allocate specified memory region with specified attributes
779 * @size: Size of the region requested
780 * @align: Alignment of the memory region requested
781 * @max_addr: Maximum address of the requested region
782 * @flags: Memory region attributes to be set
783 *
784 * Allocate a region of memory with the attributes specified through the
785 * parameter. The max_addr parameter is used to specify the maximum address
786 * below which the requested region should be allocated.
787 *
788 * Return: base address on success, 0 on error
789 */
790phys_addr_t lmb_alloc_base_flags(phys_size_t size, ulong align,
791 phys_addr_t max_addr, uint flags)
792{
793 phys_addr_t alloc;
794
Sughosh Ganu99b59662024-10-15 21:07:17 +0530795 alloc = _lmb_alloc_base(size, align, max_addr, flags);
Sughosh Ganu7f15d322024-10-15 21:07:03 +0530796
797 if (alloc == 0)
798 printf("ERROR: Failed to allocate 0x%lx bytes below 0x%lx.\n",
799 (ulong)size, (ulong)max_addr);
800
801 return alloc;
802}
803
Sughosh Ganu99b59662024-10-15 21:07:17 +0530804static phys_addr_t _lmb_alloc_addr(phys_addr_t base, phys_size_t size,
Sughosh Ganu50e27272024-08-26 17:29:19 +0530805 enum lmb_flags flags)
Simon Goldschmidt7a6ee462019-01-14 22:38:18 +0100806{
Simon Goldschmidtf41f7d62019-01-21 20:29:56 +0100807 long rgn;
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530808 struct lmb_region *lmb_memory = lmb.free_mem.data;
Simon Goldschmidt7a6ee462019-01-14 22:38:18 +0100809
810 /* Check if the requested address is in one of the memory regions */
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530811 rgn = lmb_overlaps_region(&lmb.free_mem, base, size);
Simon Goldschmidtf41f7d62019-01-21 20:29:56 +0100812 if (rgn >= 0) {
Simon Goldschmidt7a6ee462019-01-14 22:38:18 +0100813 /*
814 * Check if the requested end address is in the same memory
815 * region we found.
816 */
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530817 if (lmb_addrs_overlap(lmb_memory[rgn].base,
818 lmb_memory[rgn].size,
Simon Goldschmidtf41f7d62019-01-21 20:29:56 +0100819 base + size - 1, 1)) {
Simon Goldschmidt7a6ee462019-01-14 22:38:18 +0100820 /* ok, reserve the memory */
Sughosh Ganu50e27272024-08-26 17:29:19 +0530821 if (lmb_reserve_flags(base, size, flags) >= 0)
Simon Goldschmidt7a6ee462019-01-14 22:38:18 +0100822 return base;
823 }
824 }
Sughosh Ganu50e27272024-08-26 17:29:19 +0530825
Simon Goldschmidt7a6ee462019-01-14 22:38:18 +0100826 return 0;
827}
828
Sughosh Ganu50e27272024-08-26 17:29:19 +0530829/*
830 * Try to allocate a specific address range: must be in defined memory but not
831 * reserved
832 */
833phys_addr_t lmb_alloc_addr(phys_addr_t base, phys_size_t size)
834{
Sughosh Ganu99b59662024-10-15 21:07:17 +0530835 return _lmb_alloc_addr(base, size, LMB_NONE);
Sughosh Ganu50e27272024-08-26 17:29:19 +0530836}
837
Sughosh Ganu7f15d322024-10-15 21:07:03 +0530838/**
839 * lmb_alloc_addr_flags() - Allocate specified memory address with specified attributes
840 * @base: Base Address requested
841 * @size: Size of the region requested
842 * @flags: Memory region attributes to be set
843 *
844 * Allocate a region of memory with the attributes specified through the
845 * parameter. The base parameter is used to specify the base address
846 * of the requested region.
847 *
848 * Return: base address on success, 0 on error
849 */
850phys_addr_t lmb_alloc_addr_flags(phys_addr_t base, phys_size_t size,
851 uint flags)
852{
Sughosh Ganu99b59662024-10-15 21:07:17 +0530853 return _lmb_alloc_addr(base, size, flags);
Sughosh Ganu7f15d322024-10-15 21:07:03 +0530854}
855
Simon Goldschmidt7a6ee462019-01-14 22:38:18 +0100856/* Return number of bytes from a given address that are free */
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530857phys_size_t lmb_get_free_size(phys_addr_t addr)
Simon Goldschmidt7a6ee462019-01-14 22:38:18 +0100858{
859 int i;
Simon Goldschmidtf41f7d62019-01-21 20:29:56 +0100860 long rgn;
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530861 struct lmb_region *lmb_used = lmb.used_mem.data;
862 struct lmb_region *lmb_memory = lmb.free_mem.data;
Simon Goldschmidt7a6ee462019-01-14 22:38:18 +0100863
864 /* check if the requested address is in the memory regions */
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530865 rgn = lmb_overlaps_region(&lmb.free_mem, addr, 1);
Simon Goldschmidtf41f7d62019-01-21 20:29:56 +0100866 if (rgn >= 0) {
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530867 for (i = 0; i < lmb.used_mem.count; i++) {
868 if (addr < lmb_used[i].base) {
Simon Goldschmidt7a6ee462019-01-14 22:38:18 +0100869 /* first reserved range > requested address */
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530870 return lmb_used[i].base - addr;
Simon Goldschmidt7a6ee462019-01-14 22:38:18 +0100871 }
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530872 if (lmb_used[i].base +
873 lmb_used[i].size > addr) {
Simon Goldschmidt7a6ee462019-01-14 22:38:18 +0100874 /* requested addr is in this reserved range */
875 return 0;
876 }
877 }
878 /* if we come here: no reserved ranges above requested addr */
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530879 return lmb_memory[lmb.free_mem.count - 1].base +
880 lmb_memory[lmb.free_mem.count - 1].size - addr;
Simon Goldschmidt7a6ee462019-01-14 22:38:18 +0100881 }
882 return 0;
883}
884
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530885int lmb_is_reserved_flags(phys_addr_t addr, int flags)
Kumar Gala6d7bfa82008-02-27 21:51:47 -0600886{
887 int i;
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530888 struct lmb_region *lmb_used = lmb.used_mem.data;
Kumar Gala6d7bfa82008-02-27 21:51:47 -0600889
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530890 for (i = 0; i < lmb.used_mem.count; i++) {
891 phys_addr_t upper = lmb_used[i].base +
892 lmb_used[i].size - 1;
893 if (addr >= lmb_used[i].base && addr <= upper)
894 return (lmb_used[i].flags & flags) == flags;
Kumar Gala6d7bfa82008-02-27 21:51:47 -0600895 }
896 return 0;
897}
Mike Frysingera0dadf82009-11-03 11:35:59 -0500898
Sughosh Ganua3af5ba2024-10-15 21:07:07 +0530899static int lmb_setup(bool test)
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530900{
901 bool ret;
902
903 ret = alist_init(&lmb.free_mem, sizeof(struct lmb_region),
904 (uint)LMB_ALIST_INITIAL_SIZE);
905 if (!ret) {
906 log_debug("Unable to initialise the list for LMB free memory\n");
907 return -ENOMEM;
908 }
909
910 ret = alist_init(&lmb.used_mem, sizeof(struct lmb_region),
911 (uint)LMB_ALIST_INITIAL_SIZE);
912 if (!ret) {
913 log_debug("Unable to initialise the list for LMB used memory\n");
914 return -ENOMEM;
915 }
916
Sughosh Ganua3af5ba2024-10-15 21:07:07 +0530917 lmb.test = test;
918
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530919 return 0;
920}
921
922/**
923 * lmb_init() - Initialise the LMB module
924 *
925 * Initialise the LMB lists needed for keeping the memory map. There
926 * are two lists, in form of alloced list data structure. One for the
927 * available memory, and one for the used memory. Initialise the two
928 * lists as part of board init. Add memory to the available memory
929 * list and reserve common areas by adding them to the used memory
930 * list.
931 *
932 * Return: 0 on success, -ve on error
933 */
934int lmb_init(void)
935{
936 int ret;
937
Sughosh Ganua3af5ba2024-10-15 21:07:07 +0530938 ret = lmb_setup(false);
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530939 if (ret) {
940 log_info("Unable to init LMB\n");
941 return ret;
942 }
943
Sughosh Ganu65597fa2024-08-26 17:29:23 +0530944 lmb_add_memory();
945
Sughosh Ganu6518b412024-08-26 17:29:24 +0530946 /* Reserve the U-Boot image region once U-Boot has relocated */
Simon Glassd4dce4a2024-09-29 19:49:36 -0600947 if (xpl_phase() == PHASE_SPL)
Sughosh Ganu6518b412024-08-26 17:29:24 +0530948 lmb_reserve_common_spl();
Simon Glassd4dce4a2024-09-29 19:49:36 -0600949 else if (xpl_phase() == PHASE_BOARD_R)
Sughosh Ganu6518b412024-08-26 17:29:24 +0530950 lmb_reserve_common((void *)gd->fdt_blob);
951
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530952 return 0;
953}
954
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530955struct lmb *lmb_get(void)
956{
957 return &lmb;
958}
959
Simon Glass176eba52024-10-21 10:19:31 +0200960#if CONFIG_IS_ENABLED(UNIT_TEST)
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530961int lmb_push(struct lmb *store)
962{
963 int ret;
964
965 *store = lmb;
Sughosh Ganua3af5ba2024-10-15 21:07:07 +0530966 ret = lmb_setup(true);
Sughosh Ganu291bf9c2024-08-26 17:29:18 +0530967 if (ret)
968 return ret;
969
970 return 0;
971}
972
973void lmb_pop(struct lmb *store)
974{
975 alist_uninit(&lmb.free_mem);
976 alist_uninit(&lmb.used_mem);
977 lmb = *store;
978}
979#endif /* UNIT_TEST */