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