lib/lmb.c

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