[deliverable/linux.git] / arch / powerpc / boot / simple_alloc.c

/*
 * Implement primitive realloc(3) functionality.
 *
 * Author: Mark A. Greer <mgreer@mvista.com>
 *
 * 2006 (c) MontaVista, Software, Inc.  This file is licensed under
 * the terms of the GNU General Public License version 2.  This program
 * is licensed "as is" without any warranty of any kind, whether express
 * or implied.
 */

#include <stddef.h>
#include "types.h"
#include "page.h"
#include "string.h"
#include "ops.h"

#define	ENTRY_BEEN_USED	0x01
#define	ENTRY_IN_USE	0x02

static struct alloc_info {
	unsigned long	flags;
	unsigned long	base;
	unsigned long	size;
} *alloc_tbl;

static unsigned long tbl_entries;
static unsigned long alloc_min;
static unsigned long next_base;
static unsigned long space_left;

/*
 * First time an entry is used, its base and size are set.
 * An entry can be freed and re-malloc'd but its base & size don't change.
 * Should be smart enough for needs of bootwrapper.
 */
static void *simple_malloc(unsigned long size)
{
	unsigned long i;
	struct alloc_info *p = alloc_tbl;

	if (size == 0)
		goto err_out;

	size = _ALIGN_UP(size, alloc_min);

	for (i=0; i<tbl_entries; i++, p++)
		if (!(p->flags & ENTRY_BEEN_USED)) { /* never been used */
			if (size <= space_left) {
				p->base = next_base;
				p->size = size;
				p->flags = ENTRY_BEEN_USED | ENTRY_IN_USE;
				next_base += size;
				space_left -= size;
				return (void *)p->base;
			}
			goto err_out; /* not enough space left */
		}
		/* reuse an entry keeping same base & size */
		else if (!(p->flags & ENTRY_IN_USE) && (size <= p->size)) {
			p->flags |= ENTRY_IN_USE;
			return (void *)p->base;
		}
err_out:
	return NULL;
}

static struct alloc_info *simple_find_entry(void *ptr)
{
	unsigned long i;
	struct alloc_info *p = alloc_tbl;

	for (i=0; i<tbl_entries; i++,p++) {
		if (!(p->flags & ENTRY_BEEN_USED))
			break;
		if ((p->flags & ENTRY_IN_USE) &&
		    (p->base == (unsigned long)ptr))
			return p;
	}
	return NULL;
}

static void simple_free(void *ptr)
{
	struct alloc_info *p = simple_find_entry(ptr);

	if (p != NULL)
		p->flags &= ~ENTRY_IN_USE;
}

/*
 * Change size of area pointed to by 'ptr' to 'size'.
 * If 'ptr' is NULL, then its a malloc().  If 'size' is 0, then its a free().
 * 'ptr' must be NULL or a pointer to a non-freed area previously returned by
 * simple_realloc() or simple_malloc().
 */
static void *simple_realloc(void *ptr, unsigned long size)
{
	struct alloc_info *p;
	void *new;

	if (size == 0) {
		simple_free(ptr);
		return NULL;
	}

	if (ptr == NULL)
		return simple_malloc(size);

	p = simple_find_entry(ptr);
	if (p == NULL) /* ptr not from simple_malloc/simple_realloc */
		return NULL;
	if (size <= p->size) /* fits in current block */
		return ptr;

	new = simple_malloc(size);
	memcpy(new, ptr, p->size);
	simple_free(ptr);
	return new;
}

/*
 * Returns addr of first byte after heap so caller can see if it took
 * too much space.  If so, change args & try again.
 */
void *simple_alloc_init(char *base, unsigned long heap_size,
			unsigned long granularity, unsigned long max_allocs)
{
	unsigned long heap_base, tbl_size;

	heap_size = _ALIGN_UP(heap_size, granularity);
	alloc_min = granularity;
	tbl_entries = max_allocs;

	tbl_size = tbl_entries * sizeof(struct alloc_info);

	alloc_tbl = (struct alloc_info *)_ALIGN_UP((unsigned long)base, 8);
	memset(alloc_tbl, 0, tbl_size);

	heap_base = _ALIGN_UP((unsigned long)alloc_tbl + tbl_size, alloc_min);

	next_base = heap_base;
	space_left = heap_size;

	platform_ops.malloc = simple_malloc;
	platform_ops.free = simple_free;
	platform_ops.realloc = simple_realloc;

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