1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Implement primitive realloc(3) functionality.
4 *
5 * Author: Mark A. Greer <mgreer@mvista.com>
6 *
7 * 2006 (c) MontaVista, Software, Inc.
8 */
9
10#include <stddef.h>
11#include "types.h"
12#include "page.h"
13#include "string.h"
14#include "ops.h"
15
16#define	ENTRY_BEEN_USED	0x01
17#define	ENTRY_IN_USE	0x02
18
19static struct alloc_info {
20	unsigned long	flags;
21	unsigned long	base;
22	unsigned long	size;
23} *alloc_tbl;
24
25static unsigned long tbl_entries;
26static unsigned long alloc_min;
27static unsigned long next_base;
28static unsigned long space_left;
29
30/*
31 * First time an entry is used, its base and size are set.
32 * An entry can be freed and re-malloc'd but its base & size don't change.
33 * Should be smart enough for needs of bootwrapper.
34 */
35static void *simple_malloc(unsigned long size)
36{
37	unsigned long i;
38	struct alloc_info *p = alloc_tbl;
39
40	if (size == 0)
41		goto err_out;
42
43	size = _ALIGN_UP(size, alloc_min);
44
45	for (i=0; i<tbl_entries; i++, p++)
46		if (!(p->flags & ENTRY_BEEN_USED)) { /* never been used */
47			if (size <= space_left) {
48				p->base = next_base;
49				p->size = size;
50				p->flags = ENTRY_BEEN_USED | ENTRY_IN_USE;
51				next_base += size;
52				space_left -= size;
53				return (void *)p->base;
54			}
55			goto err_out; /* not enough space left */
56		}
57		/* reuse an entry keeping same base & size */
58		else if (!(p->flags & ENTRY_IN_USE) && (size <= p->size)) {
59			p->flags |= ENTRY_IN_USE;
60			return (void *)p->base;
61		}
62err_out:
63	return NULL;
64}
65
66static struct alloc_info *simple_find_entry(void *ptr)
67{
68	unsigned long i;
69	struct alloc_info *p = alloc_tbl;
70
71	for (i=0; i<tbl_entries; i++,p++) {
72		if (!(p->flags & ENTRY_BEEN_USED))
73			break;
74		if ((p->flags & ENTRY_IN_USE) &&
75		    (p->base == (unsigned long)ptr))
76			return p;
77	}
78	return NULL;
79}
80
81static void simple_free(void *ptr)
82{
83	struct alloc_info *p = simple_find_entry(ptr);
84
85	if (p != NULL)
86		p->flags &= ~ENTRY_IN_USE;
87}
88
89/*
90 * Change size of area pointed to by 'ptr' to 'size'.
91 * If 'ptr' is NULL, then its a malloc().  If 'size' is 0, then its a free().
92 * 'ptr' must be NULL or a pointer to a non-freed area previously returned by
93 * simple_realloc() or simple_malloc().
94 */
95static void *simple_realloc(void *ptr, unsigned long size)
96{
97	struct alloc_info *p;
98	void *new;
99
100	if (size == 0) {
101		simple_free(ptr);
102		return NULL;
103	}
104
105	if (ptr == NULL)
106		return simple_malloc(size);
107
108	p = simple_find_entry(ptr);
109	if (p == NULL) /* ptr not from simple_malloc/simple_realloc */
110		return NULL;
111	if (size <= p->size) /* fits in current block */
112		return ptr;
113
114	new = simple_malloc(size);
115	if (new) {
116		memcpy(new, ptr, p->size);
117		simple_free(ptr);
118	}
119
120	return new;
121}
122
123/*
124 * Returns addr of first byte after heap so caller can see if it took
125 * too much space.  If so, change args & try again.
126 */
127void *simple_alloc_init(char *base, unsigned long heap_size,
128			unsigned long granularity, unsigned long max_allocs)
129{
130	unsigned long heap_base, tbl_size;
131
132	heap_size = _ALIGN_UP(heap_size, granularity);
133	alloc_min = granularity;
134	tbl_entries = max_allocs;
135
136	tbl_size = tbl_entries * sizeof(struct alloc_info);
137
138	alloc_tbl = (struct alloc_info *)_ALIGN_UP((unsigned long)base, 8);
139	memset(alloc_tbl, 0, tbl_size);
140
141	heap_base = _ALIGN_UP((unsigned long)alloc_tbl + tbl_size, alloc_min);
142
143	next_base = heap_base;
144	space_left = heap_size;
145
146	platform_ops.malloc = simple_malloc;
147	platform_ops.free = simple_free;
148	platform_ops.realloc = simple_realloc;
149
150	return (void *)(heap_base + heap_size);
151}
152