303 lines
8.6 KiB
C++
303 lines
8.6 KiB
C++
/*
|
|
* \brief Platform interface implementation
|
|
* \author Norman Feske
|
|
* \date 2009-10-02
|
|
*/
|
|
|
|
/*
|
|
* Copyright (C) 2009-2013 Genode Labs GmbH
|
|
*
|
|
* This file is part of the Genode OS framework, which is distributed
|
|
* under the terms of the GNU General Public License version 2.
|
|
*/
|
|
|
|
/* Genode includes */
|
|
#include <base/printf.h>
|
|
#include <base/sleep.h>
|
|
#include <base/thread.h>
|
|
|
|
/* core includes */
|
|
#include <core_parent.h>
|
|
#include <platform.h>
|
|
#include <map_local.h>
|
|
|
|
/* Codezero includes */
|
|
#include <codezero/syscalls.h>
|
|
|
|
using namespace Genode;
|
|
|
|
enum { verbose_boot_info = true };
|
|
|
|
/*
|
|
* Memory-layout information provided by the linker script
|
|
*/
|
|
|
|
/* virtual address range consumed by core's program image */
|
|
extern unsigned _prog_img_beg, _prog_img_end;
|
|
|
|
/* physical address range occupied by core */
|
|
extern addr_t _vma_start, _lma_start;
|
|
|
|
|
|
/**************************
|
|
** Boot-module handling **
|
|
**************************/
|
|
|
|
/**
|
|
* Scan ROM module image for boot modules
|
|
*
|
|
* By convention, the boot modules start at the page after core's BSS segment.
|
|
*/
|
|
int Platform::_init_rom_fs()
|
|
{
|
|
/**
|
|
* Format of module meta-data as found in the ROM module image
|
|
*/
|
|
struct Module
|
|
{
|
|
long name; /* physical address of null-terminated string */
|
|
long base; /* physical address of module data */
|
|
long size; /* size of module data in bytes */
|
|
};
|
|
|
|
/* find base address of ROM module image */
|
|
addr_t phys_base = round_page((addr_t)&_prog_img_end);
|
|
|
|
/* map the first page of the image containing the module meta data */
|
|
class Out_of_virtual_memory_during_rom_fs_init { };
|
|
void *virt_base = 0;
|
|
if (!_core_mem_alloc.virt_alloc()->alloc(get_page_size(), &virt_base))
|
|
throw Out_of_virtual_memory_during_rom_fs_init();
|
|
|
|
if (!map_local(phys_base, (addr_t)virt_base, 1)) {
|
|
PERR("map_local failed");
|
|
return -1;
|
|
}
|
|
|
|
/* remove page containing module infos from physical memory allocator */
|
|
_core_mem_alloc.phys_alloc()->remove_range(phys_base, get_page_size());
|
|
|
|
/* validate the presence of a ROM image by checking the magic cookie */
|
|
const char cookie[4] = {'G', 'R', 'O', 'M'};
|
|
for (size_t i = 0; i < sizeof(cookie); i++)
|
|
if (cookie[i] != ((char *)virt_base)[i]) {
|
|
PERR("could not detect ROM modules");
|
|
return -2;
|
|
}
|
|
|
|
printf("detected ROM module image at 0x%p\n", (void *)phys_base);
|
|
|
|
/* detect overly large meta data, we only support 4K */
|
|
addr_t end_of_header = ((long *)virt_base)[1];
|
|
size_t header_size = end_of_header - (long)phys_base;
|
|
if (header_size > get_page_size()) {
|
|
PERR("ROM fs module header exceeds %d bytes", get_page_size());
|
|
return -3;
|
|
}
|
|
|
|
/* start of module list */
|
|
Module *module = (Module *)((addr_t)virt_base + 2*sizeof(long));
|
|
|
|
/*
|
|
* Interate over module list and populate core's ROM file system with
|
|
* 'Rom_module' objects.
|
|
*/
|
|
for (; module->name; module++) {
|
|
|
|
/* convert physical address of module name to core-local address */
|
|
char *name = (char *)(module->name - phys_base + (addr_t)virt_base);
|
|
|
|
printf("ROM module \"%s\" at physical address 0x%p, size=%zd\n",
|
|
name, (void *)module->base, (size_t)module->size);
|
|
|
|
Rom_module *rom_module = new (core_mem_alloc())
|
|
Rom_module(module->base, module->size, name);
|
|
|
|
_rom_fs.insert(rom_module);
|
|
|
|
/* remove module from physical memory allocator */
|
|
_core_mem_alloc.phys_alloc()->remove_range(module->base, round_page(module->size));
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
/****************************************
|
|
** Support for core memory management **
|
|
****************************************/
|
|
|
|
bool Core_mem_allocator::Mapped_mem_allocator::_map_local(addr_t virt_addr,
|
|
addr_t phys_addr,
|
|
unsigned size)
|
|
{
|
|
return map_local(phys_addr, virt_addr, size / get_page_size());
|
|
}
|
|
|
|
|
|
bool Core_mem_allocator::Mapped_mem_allocator::_unmap_local(addr_t virt_addr,
|
|
unsigned size)
|
|
{
|
|
return unmap_local(virt_addr, size / get_page_size());
|
|
}
|
|
|
|
|
|
/************************
|
|
** Platform interface **
|
|
************************/
|
|
|
|
Platform::Platform() :
|
|
_io_mem_alloc(core_mem_alloc()), _io_port_alloc(core_mem_alloc()),
|
|
_irq_alloc(core_mem_alloc()), _vm_base(0), _vm_size(0)
|
|
{
|
|
using namespace Codezero;
|
|
|
|
/* init core UTCB */
|
|
static char main_utcb[PAGE_SIZE] __attribute__((aligned(PAGE_SIZE)));
|
|
static struct exregs_data exregs;
|
|
exregs_set_utcb(&exregs, (unsigned long)&main_utcb[0]);
|
|
l4_exchange_registers(&exregs, thread_myself());
|
|
|
|
/* error handling is futile at this point */
|
|
|
|
/* read number of capabilities */
|
|
int num_caps;
|
|
int ret;
|
|
if ((ret = l4_capability_control(CAP_CONTROL_NCAPS,
|
|
0, &num_caps)) < 0) {
|
|
PERR("l4_capability_control(CAP_CONTROL_NCAPS) returned %d", ret);
|
|
class Could_not_obtain_num_of_capabilities { };
|
|
throw Could_not_obtain_num_of_capabilities();
|
|
}
|
|
|
|
struct capability cap_array[num_caps];
|
|
|
|
if (verbose_boot_info)
|
|
printf("allocated cap array[%d] of size %d on stack\n",
|
|
num_caps, sizeof(cap_array));
|
|
|
|
/* read all capabilities */
|
|
if ((ret = l4_capability_control(CAP_CONTROL_READ,
|
|
0, cap_array)) < 0) {
|
|
PERR("l4_capability_control(CAP_CONTROL_READ) returned %d", ret);
|
|
class Read_caps_failed { };
|
|
throw Read_caps_failed();
|
|
}
|
|
|
|
/* initialize core allocators */
|
|
bool phys_mem_defined = false;
|
|
addr_t dev_mem_base = 0;
|
|
for (int i = 0; i < num_caps; i++) {
|
|
struct capability *cap = &cap_array[i];
|
|
|
|
addr_t base = cap->start << get_page_size_log2(),
|
|
size = cap->size << get_page_size_log2();
|
|
|
|
if (verbose_boot_info)
|
|
printf("cap type=%x, rtype=%x, base=%lx, size=%lx\n",
|
|
cap_type(cap), cap_rtype(cap), base, size);
|
|
|
|
switch (cap_type(cap)) {
|
|
|
|
case CAP_TYPE_MAP_VIRTMEM:
|
|
|
|
/*
|
|
* Use first non-UTCB virtual address range as default
|
|
* virtual memory range usable for all processes.
|
|
*/
|
|
if (_vm_size == 0) {
|
|
|
|
/* exclude page at virtual address 0 */
|
|
if (base == 0 && size >= get_page_size()) {
|
|
base += get_page_size();
|
|
size -= get_page_size();
|
|
}
|
|
|
|
_vm_base = base;
|
|
_vm_size = size;
|
|
|
|
/* add range as free range to core's virtual address allocator */
|
|
_core_mem_alloc.virt_alloc()->add_range(base, size);
|
|
break;
|
|
}
|
|
|
|
PWRN("ignoring additional virtual address range [%lx,%lx)",
|
|
base, base + size);
|
|
break;
|
|
|
|
case CAP_TYPE_MAP_PHYSMEM:
|
|
|
|
/*
|
|
* We interpret the first physical memory resource that is bigger
|
|
* than typical device resources as RAM.
|
|
*/
|
|
enum { RAM_SIZE_MIN = 16*1024*1024 };
|
|
if (!phys_mem_defined && size > RAM_SIZE_MIN) {
|
|
_core_mem_alloc.phys_alloc()->add_range(base, size);
|
|
phys_mem_defined = true;
|
|
dev_mem_base = base + size;
|
|
}
|
|
break;
|
|
|
|
case CAP_TYPE_IPC:
|
|
case CAP_TYPE_UMUTEX:
|
|
case CAP_TYPE_IRQCTRL:
|
|
case CAP_TYPE_QUANTITY:
|
|
break;
|
|
}
|
|
}
|
|
|
|
addr_t core_virt_beg = trunc_page((addr_t)&_prog_img_beg),
|
|
core_virt_end = round_page((addr_t)&_prog_img_end);
|
|
size_t core_size = core_virt_end - core_virt_beg;
|
|
|
|
printf("core image:\n");
|
|
printf(" virtual address range [%08lx,%08lx) size=0x%zx\n",
|
|
core_virt_beg, core_virt_end, core_size);
|
|
printf(" physically located at 0x%08lx\n", _lma_start);
|
|
|
|
/* remove core image from core's virtual address allocator */
|
|
_core_mem_alloc.virt_alloc()->remove_range(core_virt_beg, core_size);
|
|
|
|
/* preserve context area in core's virtual address space */
|
|
_core_mem_alloc.virt_alloc()->raw()->remove_range(Native_config::context_area_virtual_base(),
|
|
Native_config::context_area_virtual_size());
|
|
|
|
/* remove used core memory from physical memory allocator */
|
|
_core_mem_alloc.phys_alloc()->remove_range(_lma_start, core_size);
|
|
|
|
/* remove magically mapped UART from core virtual memory */
|
|
_core_mem_alloc.virt_alloc()->remove_range(USERSPACE_CONSOLE_VBASE, get_page_size());
|
|
|
|
/* add boot modules to ROM fs */
|
|
if (_init_rom_fs() < 0) {
|
|
PERR("initialization of romfs failed - halt.");
|
|
while(1);
|
|
}
|
|
|
|
/* initialize interrupt allocator */
|
|
_irq_alloc.add_range(0, 255);
|
|
|
|
/* regard physical addresses higher than memory area as MMIO */
|
|
_io_mem_alloc.add_range(dev_mem_base, 0x80000000 - dev_mem_base);
|
|
|
|
/*
|
|
* Print statistics about allocator initialization
|
|
*/
|
|
printf("VM area at [%08lx,%08lx)\n", _vm_base, _vm_base + _vm_size);
|
|
|
|
if (verbose_boot_info) {
|
|
printf(":phys_alloc: "); _core_mem_alloc.phys_alloc()->raw()->dump_addr_tree();
|
|
printf(":virt_alloc: "); _core_mem_alloc.virt_alloc()->raw()->dump_addr_tree();
|
|
printf(":io_mem_alloc: "); _io_mem_alloc.raw()->dump_addr_tree();
|
|
}
|
|
}
|
|
|
|
|
|
void Platform::wait_for_exit()
|
|
{
|
|
sleep_forever();
|
|
}
|
|
|
|
|
|
void Core_parent::exit(int exit_value) { }
|