1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2019 Fuzhou Rockchip Electronics Co., Ltd 4 */ 5 6 #include <common.h> 7 #include <bidram.h> 8 #include <sysmem.h> 9 #include <lmb.h> 10 #include <malloc.h> 11 #include <asm/io.h> 12 13 DECLARE_GLOBAL_DATA_PTR; 14 15 #define SYSMEM_MAGIC 0x4D454D53 /* "SMEM" */ 16 17 #define LMB_ALLOC_ANYWHERE 0 /* sync with lmb.c */ 18 #define SYSMEM_ALLOC_NO_ALIGN 1 19 #define SYSMEM_ALLOC_ANYWHERE 2 20 21 #define SYSMEM_I(fmt, args...) printf("Sysmem: "fmt, ##args) 22 #define SYSMEM_W(fmt, args...) printf("Sysmem Warn: "fmt, ##args) 23 #define SYSMEM_E(fmt, args...) printf("Sysmem Error: "fmt, ##args) 24 #define SYSMEM_D(fmt, args...) debug("Sysmem Debug: "fmt, ##args) 25 26 struct memcheck { 27 uint32_t magic; 28 }; 29 30 /* Global for platform, must in data section */ 31 struct sysmem plat_sysmem __section(".data") = { 32 .has_initf = false, 33 .has_initr = false, 34 }; 35 36 bool sysmem_has_init(void) 37 { 38 return gd->flags & GD_FLG_RELOC ? 39 plat_sysmem.has_initr : plat_sysmem.has_initf; 40 } 41 42 static inline int sysmem_is_overlap(phys_addr_t base1, phys_size_t size1, 43 phys_addr_t base2, phys_size_t size2) 44 { 45 return ((base1 < (base2 + size2)) && (base2 < (base1 + size1))); 46 } 47 48 static inline int sysmem_is_sub_region(struct memblock *sub, 49 struct memblock *main) 50 { 51 if (!sub || !main) 52 return false; 53 54 return ((sub->base >= main->base) && 55 (sub->base + sub->size <= main->base + main->size)); 56 } 57 58 void sysmem_dump(void) 59 { 60 struct sysmem *sysmem = &plat_sysmem; 61 struct lmb *lmb = &sysmem->lmb; 62 struct memblock *mem; 63 struct memcheck *check; 64 struct list_head *node; 65 ulong memory_size = 0; 66 ulong reserved_size = 0; 67 ulong allocated_size = 0; 68 bool overflow = false; 69 ulong i; 70 71 if (!sysmem_has_init()) 72 return; 73 74 printf("\nsysmem_dump_all:\n"); 75 76 /* Memory pool */ 77 printf(" --------------------------------------------------------------------\n"); 78 for (i = 0; i < lmb->memory.cnt; i++) { 79 memory_size += lmb->memory.region[i].size; 80 printf(" memory.rgn[%ld].addr = 0x%08lx - 0x%08lx (size: 0x%08lx)\n", i, 81 (ulong)lmb->memory.region[i].base, 82 (ulong)lmb->memory.region[i].base + 83 (ulong)lmb->memory.region[i].size, 84 (ulong)lmb->memory.region[i].size); 85 } 86 printf("\n memory.total = 0x%08lx (%ld MiB. %ld KiB)\n", 87 (ulong)memory_size, 88 SIZE_MB((ulong)memory_size), 89 SIZE_KB((ulong)memory_size)); 90 91 /* Allocated */ 92 i = 0; 93 printf(" --------------------------------------------------------------------\n"); 94 list_for_each(node, &sysmem->allocated_head) { 95 mem = list_entry(node, struct memblock, node); 96 allocated_size += mem->size; 97 if (mem->attr.flags & M_ATTR_OFC) { 98 check = (struct memcheck *) 99 (mem->base + mem->size - sizeof(*check)); 100 overflow = (check->magic != SYSMEM_MAGIC); 101 } else if (mem->attr.flags & M_ATTR_HOFC) { 102 check = (struct memcheck *) 103 (mem->base - sizeof(*check)); 104 overflow = (check->magic != SYSMEM_MAGIC); 105 } else { 106 overflow = false; 107 } 108 109 printf(" allocated.rgn[%ld].name = \"%s\" %s %s\n", 110 i, mem->attr.name, overflow ? " <Overflow!>" : "", 111 mem->orig_base != mem->base ? "<*>" : ""); 112 printf(" .addr = 0x%08lx - 0x%08lx (size: 0x%08lx)\n", 113 (ulong)mem->orig_base, 114 (ulong)(mem->orig_base + mem->size), 115 (ulong)mem->size); 116 i++; 117 } 118 119 /* Kernel 'reserved-memory' */ 120 i = 0; 121 printf("\n"); 122 list_for_each(node, &sysmem->kmem_resv_head) { 123 mem = list_entry(node, struct memblock, node); 124 allocated_size += mem->size; 125 printf(" kmem-resv.rgn[%ld].name = \"%s\" %s\n", 126 i, mem->attr.name, 127 mem->orig_base != mem->base ? "<*>" : ""); 128 printf(" .addr = 0x%08lx - 0x%08lx (size: 0x%08lx)\n", 129 (ulong)mem->orig_base, 130 (ulong)(mem->orig_base + mem->size), 131 (ulong)mem->size); 132 i++; 133 } 134 135 printf("\n framework malloc_r = %3d MiB", 136 SIZE_MB(CONFIG_SYS_MALLOC_LEN)); 137 printf("\n framework malloc_f = %3d KiB\n", 138 SIZE_KB(CONFIG_SYS_MALLOC_F_LEN)); 139 140 printf("\n allocated.total = 0x%08lx (%ld MiB. %ld KiB)\n", 141 (ulong)allocated_size, 142 SIZE_MB((ulong)allocated_size), 143 SIZE_KB((ulong)allocated_size)); 144 145 /* LMB core reserved */ 146 printf(" --------------------------------------------------------------------\n"); 147 reserved_size = 0; 148 for (i = 0; i < lmb->reserved.cnt; i++) { 149 reserved_size += lmb->reserved.region[i].size; 150 printf(" LMB.allocated[%ld].addr = 0x%08lx - 0x%08lx (size: 0x%08lx)\n", i, 151 (ulong)lmb->reserved.region[i].base, 152 (ulong)lmb->reserved.region[i].base + 153 (ulong)lmb->reserved.region[i].size, 154 (ulong)lmb->reserved.region[i].size); 155 } 156 157 printf("\n reserved.core.total = 0x%08lx (%ld MiB. %ld KiB)\n", 158 (ulong)reserved_size, 159 SIZE_MB((ulong)reserved_size), 160 SIZE_KB((ulong)reserved_size)); 161 printf(" --------------------------------------------------------------------\n\n"); 162 } 163 164 void sysmem_overflow_check(void) 165 { 166 struct sysmem *sysmem = &plat_sysmem; 167 struct list_head *node, *knode; 168 struct memcheck *check; 169 struct memblock *kmem; 170 struct memblock *smem; 171 struct memblock *rmem; 172 int overflow = 0, overlap = 0; 173 174 if (!sysmem_has_init()) 175 return; 176 177 #ifdef CONFIG_BIDRAM 178 /* 179 * Check kernel 'reserved-memory' overlap with invisible regions 180 * 181 * Here, only print warning message when overlap with invisible region 182 */ 183 list_for_each(knode, &sysmem->kmem_resv_head) { 184 kmem = list_entry(knode, struct memblock, node); 185 rmem = bidram_reserved_is_overlap(kmem->base, kmem->size); 186 if (rmem) { 187 const char *alias; 188 int i, dump = 1; 189 190 /* 191 * Ignore the sub region of invisible region. 192 * eg: ramoops of SHM. 193 */ 194 alias = rmem->attr.alias[0]; 195 if (alias && sysmem_is_sub_region(kmem, rmem)) { 196 for (i = 0; i < ALIAS_COUNT_MAX; i++, alias++) { 197 alias = rmem->attr.alias[i]; 198 if (!alias) 199 continue; 200 if (!strncasecmp(kmem->attr.name, alias, 201 strlen(alias))) { 202 dump = 0; 203 break; 204 } 205 } 206 } 207 208 if (dump) 209 SYSMEM_W("kernel 'reserved-memory' \"%s\"(0x%08lx - 0x%08lx) " 210 "is overlap with [invisible] \"%s\" (0x%08lx - 0x%08lx)\n", 211 kmem->attr.name, (ulong)kmem->base, 212 (ulong)(kmem->base + kmem->size), 213 rmem->attr.name, (ulong)rmem->base, 214 (ulong)(rmem->base + rmem->size)); 215 } 216 } 217 #endif 218 219 list_for_each(node, &sysmem->allocated_head) { 220 smem = list_entry(node, struct memblock, node); 221 /* 222 * Check kernel 'reserved-memory' overlap with sysmem allocated regions 223 */ 224 list_for_each(knode, &sysmem->kmem_resv_head) { 225 kmem = list_entry(knode, struct memblock, node); 226 if (sysmem_is_overlap(smem->base, smem->size, 227 kmem->base, kmem->size)) { 228 if (smem->attr.flags & M_ATTR_KMEM_CAN_OVERLAP) 229 continue; 230 231 overlap = 1; 232 SYSMEM_W("kernel 'reserved-memory' \"%s\"(0x%08lx - 0x%08lx) " 233 "is overlap with \"%s\" (0x%08lx - 0x%08lx)\n", 234 kmem->attr.name, (ulong)kmem->base, 235 (ulong)(kmem->base + kmem->size), 236 smem->attr.name, (ulong)smem->base, 237 (ulong)(smem->base + smem->size)); 238 } 239 } 240 241 /* 242 * Check sysmem allocated regions overflow. 243 */ 244 if (smem->attr.flags & M_ATTR_OFC) { 245 check = (struct memcheck *) 246 (smem->base + smem->size - sizeof(*check)); 247 overflow = (check->magic != SYSMEM_MAGIC); 248 } else if (smem->attr.flags & M_ATTR_HOFC) { 249 check = (struct memcheck *) 250 (smem->base - sizeof(*check)); 251 overflow = (check->magic != SYSMEM_MAGIC); 252 } else { 253 overflow = 0; 254 } 255 256 if (overflow) { 257 SYSMEM_E("Found there is region overflow!\n"); 258 break; 259 } 260 } 261 262 if (overflow || overlap) 263 sysmem_dump(); 264 } 265 266 static int sysmem_add(phys_addr_t base, phys_size_t size) 267 { 268 struct sysmem *sysmem = &plat_sysmem; 269 int ret; 270 271 if (!size) 272 return -EINVAL; 273 274 ret = lmb_add(&sysmem->lmb, base, size); 275 if (ret < 0) 276 SYSMEM_E("Failed to add sysmem at 0x%08lx for 0x%08lx size\n", 277 (ulong)base, (ulong)size); 278 279 return (ret >= 0) ? 0 : ret; 280 } 281 282 static const char *sysmem_alias2name(const char *name, int *id) 283 { 284 const char *alias; 285 int i, j; 286 int match = 0; 287 288 for (i = 0; i < MEMBLK_ID_MAX; i++) { 289 /* Pirmary name */ 290 if (mem_attr[i].name && !strcasecmp(mem_attr[i].name, name)) { 291 match = 1; 292 goto finish; 293 } 294 295 /* Alias name */ 296 alias = mem_attr[i].alias[0]; 297 if (!alias) 298 continue; 299 300 for (j = 0; j < ALIAS_COUNT_MAX; j++) { 301 alias = mem_attr[i].alias[j]; 302 if (alias && !strcasecmp(alias, name)) { 303 match = 1; 304 goto finish; 305 } 306 } 307 } 308 309 finish: 310 if (match) { 311 *id = i; 312 return mem_attr[i].name; 313 } 314 315 return name; 316 } 317 318 static void *sysmem_alloc_align_base(enum memblk_id id, 319 const char *mem_name, 320 phys_addr_t base, 321 phys_size_t size, 322 ulong align) 323 { 324 struct sysmem *sysmem = &plat_sysmem; 325 struct memblk_attr attr; 326 struct memblock *mem; 327 struct memcheck *check; 328 struct list_head *node; 329 const char *name; 330 phys_addr_t paddr; 331 phys_addr_t alloc_base; 332 phys_size_t alloc_size; 333 phys_addr_t orig_base = base; 334 335 if (!sysmem_has_init()) 336 goto out; 337 338 if (id == MEMBLK_ID_BY_NAME || id == MEMBLK_ID_KMEM_RESERVED) { 339 if (!mem_name) { 340 SYSMEM_E("NULL name for alloc sysmem\n"); 341 goto out; 342 } 343 344 /* Find: name, id and attr by outer mem_name & id */ 345 name = sysmem_alias2name(mem_name, (int *)&id); 346 attr = mem_attr[id]; 347 if (!attr.name) 348 attr.name = strdup(name); 349 350 /* Always make kernel 'reserved-memory' alloc successfully */ 351 if (id == MEMBLK_ID_KMEM_RESERVED) { 352 struct memblock *mem; 353 354 mem = malloc(sizeof(*mem)); 355 if (!mem) { 356 SYSMEM_E("No memory for \"%s\" alloc sysmem\n", name); 357 return mem; 358 } 359 360 attr.flags |= M_ATTR_KMEM_RESERVED; 361 mem->orig_base = orig_base; 362 mem->base = base; 363 mem->size = size; 364 mem->attr = attr; 365 sysmem->kmem_resv_cnt++; 366 list_add_tail(&mem->node, &sysmem->kmem_resv_head); 367 368 return (void *)base; 369 } 370 } else if (id > MEMBLK_ID_UNK && id < MEMBLK_ID_MAX) { 371 attr = mem_attr[id]; 372 name = attr.name; 373 374 /* 375 * Special handle for Android AVB alloc(on any where) 376 * 377 * Fixup base and place right after U-Boot stack, adding a lot 378 * of space(4KB) maybe safer. 379 */ 380 if ((id == MEMBLK_ID_AVB_ANDROID) && 381 (base == SYSMEM_ALLOC_ANYWHERE)) { 382 base = gd->start_addr_sp - 383 CONFIG_SYS_STACK_SIZE - size - 0x1000; 384 385 /* 386 * The 0x0 address is usually allocated by 32-bit uncompressed 387 * kernel and this alloc action is just a peek. 388 * 389 * Due to LMB core doesn't support alloc at 0x0 address, we have 390 * to alloc the memblk backword a few bytes. 391 * 392 * ARCH_DMA_MINALIGN maybe a good choice. 393 */ 394 } else if (!base) { 395 base += ARCH_DMA_MINALIGN; 396 } else if (base <= gd->bd->bi_dram[0].start) { 397 /* 398 * On Rockchip platform: 399 * 400 * So far, we use M_ATTR_IGNORE_INVISIBLE for uncompress 401 * kernel alloc, and for ARMv8 enabling AArch32 mode, the 402 * ATF is still AArch64 and ocuppies 0~1MB and shmem 1~2M. 403 * So let's ignore the region which overlap with them. 404 */ 405 if (attr.flags & M_ATTR_IGNORE_INVISIBLE) { 406 base = gd->bd->bi_dram[0].start; 407 } else { 408 SYSMEM_E("Failed to alloc invisible sub region 0x%08lx - 0x%08lx " 409 "of \"%s\" at 0x%08lx - 0x%08lx\n", 410 (ulong)base, (ulong)gd->bd->bi_dram[0].start, 411 name, (ulong)base, (ulong)(base + size)); 412 goto out; 413 } 414 } 415 } else { 416 SYSMEM_E("Unsupport memblk id %d for alloc sysmem\n", id); 417 goto out; 418 } 419 420 if (!size) { 421 SYSMEM_E("\"%s\" size is 0 for alloc sysmem\n", name); 422 goto out; 423 } 424 425 /* 426 * Some modules use "sysmem_alloc()" to alloc region for storage 427 * read/write buffer, it should be aligned to cacheline size. eg: AVB. 428 * 429 * Aligned down to cacheline size if not aligned, otherwise the tail 430 * of region maybe overflow. 431 */ 432 if (attr.flags & M_ATTR_CACHELINE_ALIGN && 433 !IS_ALIGNED(base, ARCH_DMA_MINALIGN)) { 434 base = ALIGN(base, ARCH_DMA_MINALIGN); 435 base -= ARCH_DMA_MINALIGN; 436 } 437 438 if (base != SYSMEM_ALLOC_ANYWHERE && !IS_ALIGNED(base, 4)) { 439 SYSMEM_E("\"%s\" base=0x%08lx is not 4-byte aligned\n", 440 name, (ulong)base); 441 goto out; 442 } 443 444 /* Must be sizeof(long) byte aligned */ 445 size = ALIGN(size, sizeof(long)); 446 447 SYSMEM_D("Enter alloc: \"%s\" 0x%08lx - 0x%08lx\n", 448 name, (ulong)base, (ulong)(base + size)); 449 450 /* Already allocated ? */ 451 list_for_each(node, &sysmem->allocated_head) { 452 mem = list_entry(node, struct memblock, node); 453 SYSMEM_D("Has allcated: %s, 0x%08lx - 0x%08lx\n", 454 mem->attr.name, (ulong)mem->base, 455 (ulong)(mem->base + mem->size)); 456 if (!strcmp(mem->attr.name, name)) { 457 /* Allow double alloc for same but smaller region */ 458 if (mem->base <= base && mem->size >= size) 459 return (void *)base; 460 461 SYSMEM_E("Failed to double alloc for existence \"%s\"\n", name); 462 goto out; 463 } else if (sysmem_is_overlap(mem->base, mem->size, base, size)) { 464 SYSMEM_E("\"%s\" (0x%08lx - 0x%08lx) alloc is " 465 "overlap with existence \"%s\" (0x%08lx - " 466 "0x%08lx)\n", 467 name, (ulong)base, (ulong)(base + size), 468 mem->attr.name, (ulong)mem->base, 469 (ulong)(mem->base + mem->size)); 470 goto out; 471 } 472 } 473 474 /* Add overflow check magic ? */ 475 if (attr.flags & M_ATTR_OFC) 476 alloc_size = size + sizeof(*check); 477 else 478 alloc_size = size; 479 480 /* Alloc anywhere ? */ 481 if (base == SYSMEM_ALLOC_ANYWHERE) 482 alloc_base = LMB_ALLOC_ANYWHERE; 483 else 484 alloc_base = base + alloc_size; /* LMB is align down alloc mechanism */ 485 486 paddr = lmb_alloc_base(&sysmem->lmb, alloc_size, align, alloc_base); 487 if (paddr) { 488 if ((paddr == base) || (base == SYSMEM_ALLOC_ANYWHERE)) { 489 mem = malloc(sizeof(*mem)); 490 if (!mem) { 491 SYSMEM_E("No memory for \"%s\" alloc sysmem\n", name); 492 goto out; 493 } 494 495 /* Record original base for dump */ 496 mem->orig_base = orig_base; 497 mem->base = paddr; 498 mem->size = alloc_size; 499 mem->attr = attr; 500 sysmem->allocated_cnt++; 501 list_add_tail(&mem->node, &sysmem->allocated_head); 502 503 /* Add overflow check magic */ 504 if (mem->attr.flags & M_ATTR_OFC) { 505 check = (struct memcheck *)(paddr + size); 506 check->magic = SYSMEM_MAGIC; 507 } else if (mem->attr.flags & M_ATTR_HOFC) { 508 check = (struct memcheck *)(paddr - sizeof(*check)); 509 check->magic = SYSMEM_MAGIC; 510 } 511 } else { 512 SYSMEM_E("Failed to alloc \"%s\" expect at 0x%08lx - 0x%08lx " 513 "but at 0x%08lx - x%08lx\n", 514 name, (ulong)base, (ulong)(base + size), 515 (ulong)paddr, (ulong)(paddr + size)); 516 /* Free what we don't want allocated region */ 517 if (lmb_free(&sysmem->lmb, paddr, alloc_size) < 0) 518 SYSMEM_E("Failed to free \"%s\"\n", name); 519 520 goto out; 521 } 522 } else { 523 SYSMEM_E("Failed to alloc \"%s\" at 0x%08lx - 0x%08lx\n", 524 name, (ulong)base, (ulong)(base + size)); 525 goto out; 526 } 527 528 SYSMEM_D("Exit alloc: \"%s\", paddr=0x%08lx, size=0x%08lx, align=0x%x, anywhere=%d\n", 529 name, (ulong)paddr, (ulong)size, (u32)align, !base); 530 531 return (void *)paddr; 532 533 out: 534 /* 535 * Why: base + sizeof(ulong) ? 536 * It's not a standard way to handle the case: the input base is 0. 537 * Because 0 equals NULL, but we don't want to return NULL when alloc 538 * successfully, so just return a !NULL value is okay. 539 * 540 * When it happens ? 541 * Maybe 32-bit platform would alloc region for uncompress kernel 542 * at 0 address. 543 */ 544 if (base == 0) 545 base = base + sizeof(ulong); 546 547 return (attr.flags & M_ATTR_IGNORE_INVISIBLE) ? (void *)base : NULL; 548 } 549 550 void *sysmem_alloc(enum memblk_id id, phys_size_t size) 551 { 552 void *paddr; 553 554 paddr = sysmem_alloc_align_base(id, 555 NULL, 556 SYSMEM_ALLOC_ANYWHERE, 557 size, 558 SYSMEM_ALLOC_NO_ALIGN); 559 if (!paddr) 560 sysmem_dump(); 561 562 return paddr; 563 } 564 565 void *sysmem_alloc_by_name(const char *name, phys_size_t size) 566 { 567 void *paddr; 568 569 paddr = sysmem_alloc_align_base(MEMBLK_ID_BY_NAME, 570 name, 571 SYSMEM_ALLOC_ANYWHERE, 572 size, 573 SYSMEM_ALLOC_NO_ALIGN); 574 if (!paddr) 575 sysmem_dump(); 576 577 return paddr; 578 } 579 580 void *sysmem_alloc_base(enum memblk_id id, phys_addr_t base, phys_size_t size) 581 { 582 void *paddr; 583 584 paddr = sysmem_alloc_align_base(id, 585 NULL, 586 base, 587 size, 588 SYSMEM_ALLOC_NO_ALIGN); 589 if (!paddr) 590 sysmem_dump(); 591 592 return paddr; 593 } 594 595 void *sysmem_alloc_base_by_name(const char *name, 596 phys_addr_t base, phys_size_t size) 597 { 598 void *paddr; 599 600 paddr = sysmem_alloc_align_base(MEMBLK_ID_BY_NAME, 601 name, 602 base, 603 size, 604 SYSMEM_ALLOC_NO_ALIGN); 605 if (!paddr) 606 sysmem_dump(); 607 608 return paddr; 609 } 610 611 void *sysmem_fdt_reserve_alloc_base(const char *name, 612 phys_addr_t base, phys_size_t size) 613 { 614 void *paddr; 615 616 paddr = sysmem_alloc_align_base(MEMBLK_ID_KMEM_RESERVED, 617 name, 618 base, 619 size, 620 SYSMEM_ALLOC_NO_ALIGN); 621 if (!paddr) 622 sysmem_dump(); 623 624 return paddr; 625 } 626 627 bool sysmem_can_alloc(phys_size_t base, phys_size_t size) 628 { 629 struct sysmem *sysmem = &plat_sysmem; 630 phys_addr_t alloc_base; 631 phys_addr_t paddr; 632 int ret; 633 634 if (!sysmem_has_init()) 635 return false; 636 637 /* LMB is align down alloc mechanism */ 638 alloc_base = base + size; 639 paddr = __lmb_alloc_base(&sysmem->lmb, 640 size, 641 SYSMEM_ALLOC_NO_ALIGN, 642 alloc_base); 643 if (paddr) { 644 /* If free failed, return false */ 645 ret = lmb_free(&sysmem->lmb, base, size); 646 if (ret < 0) { 647 SYSMEM_E("Can't free at 0x%08lx - 0x%08lx, ret=%d\n", 648 (ulong)base, (ulong)(base + size), ret); 649 return false; 650 } 651 } else { 652 SYSMEM_D("Can't alloc at 0x%08lx - 0x%08lx\n", 653 (ulong)base, (ulong)(base + size)); 654 } 655 656 return (paddr == base) ? true : false; 657 } 658 659 int sysmem_free(phys_addr_t base) 660 { 661 struct sysmem *sysmem = &plat_sysmem; 662 struct memblock *mem; 663 struct list_head *node; 664 int ret, found = 0; 665 666 if (!sysmem_has_init()) 667 return -ENOSYS; 668 669 /* Find existence */ 670 list_for_each(node, &sysmem->allocated_head) { 671 mem = list_entry(node, struct memblock, node); 672 if (mem->base == base || mem->orig_base == base) { 673 found = 1; 674 break; 675 } 676 } 677 678 if (!found) { 679 SYSMEM_E("Failed to free no allocated sysmem at 0x%08lx\n", 680 (ulong)base); 681 return -EINVAL; 682 } 683 684 ret = lmb_free(&sysmem->lmb, mem->base, mem->size); 685 if (ret >= 0) { 686 SYSMEM_D("Free: \"%s\" 0x%08lx - 0x%08lx\n", 687 mem->attr.name, (ulong)mem->base, 688 (ulong)(mem->base + mem->size)); 689 sysmem->allocated_cnt--; 690 list_del(&mem->node); 691 free(mem); 692 } else { 693 SYSMEM_E("Failed to free \"%s\" at 0x%08lx\n", 694 mem->attr.name, (ulong)base); 695 } 696 697 return (ret >= 0) ? 0 : ret; 698 } 699 700 int sysmem_initr(void) 701 { 702 return sysmem_init(); 703 } 704 705 int sysmem_init(void) 706 { 707 struct sysmem *sysmem = &plat_sysmem; 708 phys_addr_t mem_start; 709 phys_size_t mem_size; 710 int ret; 711 712 lmb_init(&sysmem->lmb); 713 INIT_LIST_HEAD(&sysmem->allocated_head); 714 INIT_LIST_HEAD(&sysmem->kmem_resv_head); 715 sysmem->allocated_cnt = 0; 716 sysmem->kmem_resv_cnt = 0; 717 718 if (gd->flags & GD_FLG_RELOC) { 719 sysmem->has_initr = true; 720 } else { 721 SYSMEM_I("init\n"); 722 sysmem->has_initf = true; 723 } 724 725 /* Add all available system memory */ 726 #ifdef CONFIG_NR_DRAM_BANKS 727 int i; 728 729 for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++) { 730 if (!gd->bd->bi_dram[i].size) 731 continue; 732 733 ret = sysmem_add(gd->bd->bi_dram[i].start, 734 gd->bd->bi_dram[i].size); 735 if (ret) { 736 SYSMEM_E("Failed to add sysmem from bi_dram[%d]\n", i); 737 goto fail; 738 } 739 } 740 #else 741 mem_start = env_get_bootm_low(); 742 mem_size = env_get_bootm_size(); 743 ret = sysmem_add(mem_start, mem_size); 744 if (ret) { 745 SYSMEM_E("Failed to add sysmem from bootm_low/size\n"); 746 goto fail; 747 } 748 #endif 749 /* Reserved for board */ 750 ret = board_sysmem_reserve(sysmem); 751 if (ret) { 752 SYSMEM_E("Failed to reserve sysmem for board\n"); 753 goto fail; 754 } 755 756 /* Reserved for U-boot framework: 'reserve_xxx()' */ 757 mem_start = gd->start_addr_sp; 758 mem_size = gd->ram_top - mem_start; 759 if (!sysmem_alloc_base(MEMBLK_ID_UBOOT, mem_start, mem_size)) { 760 SYSMEM_E("Failed to reserve sysmem for U-Boot framework\n"); 761 ret = -ENOMEM; 762 goto fail; 763 } 764 765 /* Reserved for U-Boot stack */ 766 mem_start = gd->start_addr_sp - CONFIG_SYS_STACK_SIZE; 767 mem_size = CONFIG_SYS_STACK_SIZE; 768 if (!sysmem_alloc_base(MEMBLK_ID_STACK, mem_start, mem_size)) { 769 SYSMEM_E("Failed to reserve sysmem for stack\n"); 770 ret = -ENOMEM; 771 goto fail; 772 } 773 774 return 0; 775 776 fail: 777 if (ret && !(gd->flags & GD_FLG_RELOC)) { 778 sysmem_dump(); 779 SYSMEM_W("Maybe malloc size %d MiB is too large?\n\n", 780 SIZE_MB(CONFIG_SYS_MALLOC_LEN)); 781 } 782 783 return ret; 784 } 785 786 __weak int board_sysmem_reserve(struct sysmem *sysmem) 787 { 788 /* please define platform specific board_sysmem_reserve() */ 789 return 0; 790 } 791 792 static int do_dump_sysmem(cmd_tbl_t *cmdtp, int flag, 793 int argc, char *const argv[]) 794 { 795 sysmem_dump(); 796 return 0; 797 } 798 799 U_BOOT_CMD( 800 dump_sysmem, 1, 1, do_dump_sysmem, 801 "Dump sysmem layout", 802 "" 803 ); 804