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