316 lines
9 KiB
C
316 lines
9 KiB
C
/* This file is part of the program psim.
|
|
|
|
Copyright (C) 1994-1996, Andrew Cagney <cagney@highland.com.au>
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
*/
|
|
|
|
|
|
#ifndef _HW_MEMORY_C_
|
|
#define _HW_MEMORY_C_
|
|
|
|
#ifndef STATIC_INLINE_HW_MEMORY
|
|
#define STATIC_INLINE_HW_MEMORY STATIC_INLINE
|
|
#endif
|
|
|
|
#include "device_table.h"
|
|
|
|
/* DEVICE
|
|
|
|
memory - description of system memory
|
|
|
|
DESCRIPTION
|
|
|
|
This device describes the size and location of the banks of
|
|
physical memory within the simulation.
|
|
|
|
In addition, this device supports the "claim" and "release" methods
|
|
that can be used by OpenBoot client programs to manage the
|
|
allocation of physical memory.
|
|
|
|
PROPERTIES
|
|
|
|
reg = { <address> <size> } (required)
|
|
|
|
Each pair specify one bank of memory.
|
|
|
|
available = { <address> <size> } (automatic)
|
|
|
|
Each pair specifies a block of memory that is currently unallocated.
|
|
|
|
*/
|
|
|
|
typedef struct _memory_reg_spec {
|
|
unsigned32 base;
|
|
unsigned32 size;
|
|
} memory_reg_spec;
|
|
|
|
typedef struct _hw_memory_chunk hw_memory_chunk;
|
|
struct _hw_memory_chunk {
|
|
unsigned_word address;
|
|
unsigned_word size;
|
|
unsigned_word alloc_address;
|
|
unsigned_word alloc_size;
|
|
int available;
|
|
hw_memory_chunk *next;
|
|
};
|
|
|
|
typedef struct _hw_memory_device {
|
|
hw_memory_chunk *heap;
|
|
} hw_memory_device;
|
|
|
|
|
|
static void *
|
|
hw_memory_create(const char *name,
|
|
const device_unit *unit_address,
|
|
const char *args)
|
|
{
|
|
hw_memory_device *hw_memory = ZALLOC(hw_memory_device);
|
|
return hw_memory;
|
|
}
|
|
|
|
|
|
static void
|
|
hw_memory_set_available(device *me,
|
|
hw_memory_device *hw_memory)
|
|
{
|
|
hw_memory_chunk *chunk = NULL;
|
|
memory_reg_spec *available = NULL;
|
|
int nr_available = 0;
|
|
int curr = 0;
|
|
int sizeof_available = 0;
|
|
/* determine the nr of available chunks */
|
|
chunk = hw_memory->heap;
|
|
nr_available = 0;
|
|
while (chunk != NULL) {
|
|
if (chunk->available)
|
|
nr_available += 1;
|
|
chunk = chunk->next;
|
|
}
|
|
/* now create the available struct */
|
|
ASSERT(nr_available > 0);
|
|
sizeof_available = sizeof(memory_reg_spec) * nr_available;
|
|
available = zalloc(sizeof_available);
|
|
chunk = hw_memory->heap;
|
|
curr = 0;
|
|
while (chunk != NULL) {
|
|
if (chunk->available) {
|
|
available[curr].base = H2BE_4(chunk->address);
|
|
available[curr].size = H2BE_4(chunk->size);
|
|
curr += 1;
|
|
}
|
|
chunk = chunk->next;
|
|
}
|
|
/* update */
|
|
device_set_array_property(me, "available", available, sizeof_available);
|
|
zfree(available);
|
|
}
|
|
|
|
|
|
static void
|
|
hw_memory_init_address(device *me)
|
|
{
|
|
hw_memory_device *hw_memory = (hw_memory_device*)device_data(me);
|
|
const device_property *reg = device_find_array_property(me, "reg");
|
|
const memory_reg_spec *spec = reg->array;
|
|
int nr_entries = reg->sizeof_array / sizeof(*spec);
|
|
|
|
/* sanity check reg property */
|
|
if ((reg->sizeof_array % sizeof(*spec)) != 0)
|
|
error("devices/%s reg property of incorrect size\n", device_name(me));
|
|
|
|
/* free up any previous structures */
|
|
{
|
|
hw_memory_chunk *curr_chunk = hw_memory->heap;
|
|
hw_memory->heap = NULL;
|
|
while (curr_chunk != NULL) {
|
|
hw_memory_chunk *dead_chunk = curr_chunk;
|
|
curr_chunk = dead_chunk->next;
|
|
dead_chunk->next = NULL;
|
|
zfree(dead_chunk);
|
|
}
|
|
}
|
|
|
|
/* count/allocate memory entries */
|
|
{
|
|
hw_memory_chunk **curr_chunk = &hw_memory->heap;
|
|
while (nr_entries > 0) {
|
|
hw_memory_chunk *new_chunk = ZALLOC(hw_memory_chunk);
|
|
new_chunk->address = BE2H_4(spec->base);
|
|
new_chunk->size = BE2H_4(spec->size);
|
|
new_chunk->available = 1;
|
|
device_attach_address(device_parent(me),
|
|
device_name(me),
|
|
attach_raw_memory,
|
|
0 /*address space*/,
|
|
new_chunk->address,
|
|
new_chunk->size,
|
|
access_read_write_exec,
|
|
me);
|
|
spec++;
|
|
nr_entries--;
|
|
*curr_chunk = new_chunk;
|
|
curr_chunk = &new_chunk->next;
|
|
}
|
|
}
|
|
|
|
/* initialize the alloc property for this device */
|
|
hw_memory_set_available(me, hw_memory);
|
|
}
|
|
|
|
static void
|
|
hw_memory_instance_delete(device_instance *instance)
|
|
{
|
|
return;
|
|
}
|
|
|
|
static unsigned_word
|
|
hw_memory_instance_claim(device_instance *instance,
|
|
unsigned_word address,
|
|
unsigned_word size,
|
|
unsigned_word alignment)
|
|
{
|
|
hw_memory_device *hw_memory = device_instance_data(instance);
|
|
hw_memory_chunk *chunk = NULL;
|
|
DTRACE(memory, ("claim - address=0x%lx size=0x%lx alignment=%d\n",
|
|
(unsigned long)address,
|
|
(unsigned long)size,
|
|
(int)alignment));
|
|
/* find a chunk candidate, either according to address or alignment */
|
|
if (alignment == 0) {
|
|
chunk = hw_memory->heap;
|
|
while (chunk != NULL
|
|
&& (address+size) > (chunk->address+chunk->size))
|
|
chunk = chunk->next;
|
|
if (chunk == NULL || address < chunk->address || !chunk->available)
|
|
error("hw_memory_instance_claim: failed to allocate @0x%lx, size %ld\n",
|
|
(unsigned long)address, (unsigned long)size);
|
|
}
|
|
else {
|
|
chunk = hw_memory->heap;
|
|
while (chunk != NULL && chunk->size < size)
|
|
chunk = chunk->next;
|
|
if (chunk == NULL || FLOOR_PAGE(alignment-1) > 0)
|
|
error("hw_memory_instance_claim: failed to allocate %ld, align %ld\n",
|
|
(unsigned long)size, (unsigned long)size);
|
|
address = chunk->address;
|
|
}
|
|
/* break of a part before this memory if needed */
|
|
ASSERT(address >= chunk->address);
|
|
if (FLOOR_PAGE(address) > chunk->address) {
|
|
hw_memory_chunk *last_chunk = chunk;
|
|
/* insert a new earlier chunk */
|
|
chunk = ZALLOC(hw_memory_chunk);
|
|
chunk->next = last_chunk->next;
|
|
last_chunk->next = chunk;
|
|
/* adjust the address/size */
|
|
chunk->address = FLOOR_PAGE(address);
|
|
chunk->size = last_chunk->size - (chunk->address - last_chunk->address);
|
|
last_chunk->size = chunk->address - last_chunk->address;
|
|
}
|
|
ASSERT(FLOOR_PAGE(address) == chunk->address);
|
|
/* break of a bit after this chunk if needed */
|
|
if (ALIGN_PAGE(address+size) < chunk->address + chunk->size) {
|
|
hw_memory_chunk *next_chunk = ZALLOC(hw_memory_chunk);
|
|
/* insert it in to the list */
|
|
next_chunk->next = chunk->next;
|
|
chunk->next = next_chunk;
|
|
next_chunk->available = 1;
|
|
/* adjust the address/size */
|
|
next_chunk->address = ALIGN_PAGE(address+size);
|
|
next_chunk->size = chunk->address + chunk->size - next_chunk->address;
|
|
chunk->size = next_chunk->address - chunk->address;
|
|
}
|
|
ASSERT(ALIGN_PAGE(address+size) == chunk->address + chunk->size);
|
|
/* now allocate it */
|
|
chunk->alloc_address = address;
|
|
chunk->alloc_size = size;
|
|
chunk->available = 0;
|
|
hw_memory_set_available(device_instance_device(instance), hw_memory);
|
|
return address;
|
|
}
|
|
|
|
static void
|
|
hw_memory_instance_release(device_instance *instance,
|
|
unsigned_word address,
|
|
unsigned_word length)
|
|
{
|
|
hw_memory_device *hw_memory = device_instance_data(instance);
|
|
hw_memory_chunk *chunk = hw_memory->heap;
|
|
while (chunk != NULL) {
|
|
if (chunk->alloc_address == address
|
|
&& chunk->alloc_size == length
|
|
&& chunk->available == 0) {
|
|
/* free this chunk */
|
|
chunk->available = 1;
|
|
/* check for merge */
|
|
chunk = hw_memory->heap;
|
|
while (chunk != NULL) {
|
|
if (chunk->available
|
|
&& chunk->next != NULL && chunk->next->available) {
|
|
/* adjacent */
|
|
hw_memory_chunk *delete = chunk->next;
|
|
ASSERT(chunk->address + chunk->size == delete->address);
|
|
chunk->size += delete->size;
|
|
chunk->next = delete->next;
|
|
zfree(delete);
|
|
}
|
|
}
|
|
/* update the corresponding property */
|
|
hw_memory_set_available(device_instance_device(instance), hw_memory);
|
|
return;
|
|
}
|
|
chunk = chunk->next;
|
|
}
|
|
error("hw_memory_instance_release: Address 0x%lx, size %ld not found\n",
|
|
(unsigned long)address, (unsigned long)length);
|
|
/* FIXME - dump allocated */
|
|
/* FIXME - dump arguments */
|
|
}
|
|
|
|
static device_instance_callbacks const hw_memory_instance_callbacks = {
|
|
hw_memory_instance_delete,
|
|
NULL /*read*/, NULL /*write*/, NULL /*seek*/,
|
|
hw_memory_instance_claim, hw_memory_instance_release
|
|
};
|
|
|
|
static device_instance *
|
|
hw_memory_create_instance(device *me,
|
|
const char *path,
|
|
const char *args)
|
|
{
|
|
return device_create_instance_from(me, NULL,
|
|
device_data(me), /* nothing better */
|
|
path, args,
|
|
&hw_memory_instance_callbacks);
|
|
}
|
|
|
|
static device_callbacks const hw_memory_callbacks = {
|
|
{ hw_memory_init_address, },
|
|
{ NULL, }, /* address */
|
|
{ NULL, }, /* IO */
|
|
{ NULL, }, /* DMA */
|
|
{ NULL, }, /* interrupt */
|
|
{ NULL, }, /* unit */
|
|
hw_memory_create_instance,
|
|
};
|
|
|
|
const device_descriptor hw_memory_device_descriptor[] = {
|
|
{ "memory", hw_memory_create, &hw_memory_callbacks },
|
|
{ NULL },
|
|
};
|
|
|
|
#endif /* _HW_MEMORY_C_ */
|