Subversion Repositories c0or1k

/*
 * Main initialisation code for the ARM kernel
 *
 * Copyright (C) 2007 - 2010 B Labs Ltd.
 */
#include <l4/lib/mutex.h>
#include <l4/lib/printk.h>
#include <l4/lib/string.h>
#include <l4/lib/idpool.h>
#include <l4/generic/platform.h>
#include <l4/generic/scheduler.h>
#include <l4/generic/space.h>
#include <l4/generic/tcb.h>
#include <l4/generic/bootmem.h>
#include <l4/generic/resource.h>
#include <l4/generic/container.h>
#include INC_ARCH(linker.h)
#include INC_ARCH(asm.h)
#include INC_SUBARCH(mm.h)
#include INC_SUBARCH(cpu.h)
#include INC_SUBARCH(mmu_ops.h)
#include INC_SUBARCH(perfmon.h)
#include INC_GLUE(memlayout.h)
#include INC_GLUE(memory.h)
#include INC_GLUE(mapping.h)
#include INC_GLUE(message.h)
#include INC_GLUE(syscall.h)
#include INC_GLUE(init.h)
#include INC_GLUE(smp.h)
#include INC_PLAT(platform.h)
#include INC_API(syscall.h)
#include INC_API(kip.h)
#include INC_API(mutex.h)
 
unsigned int kernel_mapping_end;
 
void print_sections(void)
{
	dprintk("_start_kernel: ",(unsigned int)_start_kernel);
	dprintk("_start_text: ",(unsigned int)_start_text);
	dprintk("_end_text: ", 	(unsigned int)_end_text);
	dprintk("_start_data: ", (unsigned int)_start_data);
	dprintk("_end_data: ", 	(unsigned int)_end_data);
	dprintk("_start_vectors: ",(unsigned int)_start_vectors);
	dprintk("arm_high_vector: ",(unsigned int)arm_high_vector);
	dprintk("_end_vectors: ",(unsigned int)_end_vectors);
	dprintk("_start_kip: ", (unsigned int) _start_kip);
	dprintk("_end_kip: ", (unsigned int) _end_kip);
	dprintk("_start_syscalls: ", (unsigned int) _start_syscalls);
	dprintk("_end_syscalls: ", (unsigned int) _end_syscalls);
	dprintk("_start_bootstack: ", (unsigned int)_start_bootstack);
	dprintk("_end_bootstack: ", (unsigned int)_end_bootstack);
	dprintk("_start_bootstack: ", (unsigned int)_start_bootstack);
	dprintk("_end_bootstack: ", (unsigned int)_end_bootstack);
	dprintk("_start_init_pgd: ", (unsigned int)_start_init_pgd);
	dprintk("_end_init_pgd: ", (unsigned int)_end_init_pgd);
	dprintk("_end_kernel: ", (unsigned int)_end_kernel);
	dprintk("_start_init: ", (unsigned int)_start_init);
	dprintk("_end_init: ", (unsigned int)_end_init);
	dprintk("_end: ", (unsigned int)_end);
}
 
/* This calculates what address the kip field would have in userspace. */
#define KIP_USR_OFFSETOF(kip, field) ((void *)(((unsigned long)&kip.field - \
					(unsigned long)&kip) + USER_KIP_PAGE))
 
/* The kip is non-standard, using 0xBB to indicate mine for now ;-) */
void kip_init()
{
	struct utcb **utcb_ref;
 
	/*
	 * TODO: Adding utcb size might be useful
	 */
	memset(&kip, 0, PAGE_SIZE);
	memcpy(&kip, "L4\230K", 4); /* Name field = l4uK */
	kip.api_version 	= 0xBB;
	kip.api_subversion 	= 1;
	kip.api_flags 		= 0; 		/* LE, 32-bit architecture */
	kip.kdesc.magic		= 0xBBB;
	kip.kdesc.version	= CODEZERO_VERSION;
	kip.kdesc.subversion	= CODEZERO_SUBVERSION;
	strncpy(kip.kdesc.date, __DATE__, KDESC_DATE_SIZE);
	strncpy(kip.kdesc.time, __TIME__, KDESC_TIME_SIZE);
 
	kip_init_syscalls();
 
	/* KIP + 0xFF0 is pointer to UTCB segment start address */
	utcb_ref = (struct utcb **)((unsigned long)&kip + UTCB_KIP_OFFSET);
 
	add_boot_mapping(virt_to_phys(&kip), USER_KIP_PAGE, PAGE_SIZE,
			 MAP_USR_RO);
	printk("%s: Kernel built on %s, %s\n", __KERNELNAME__,
	       kip.kdesc.date, kip.kdesc.time);
}
 
void vectors_init()
{
	unsigned int size = ((u32)_end_vectors - (u32)arm_high_vector);
 
	/* Map the vectors in high vector page */
	add_boot_mapping(virt_to_phys(arm_high_vector),
			 ARM_HIGH_VECTOR, size, MAP_KERN_RWX);
 
	/* Kernel memory trapping is enabled at this point. */
}
 
 
#include <l4/generic/cap-types.h>
#include <l4/api/capability.h>
#include <l4/generic/capability.h>
 
/* This is what an idle task needs */
static DECLARE_PERCPU(struct capability, pmd_cap);
 
/*
 * FIXME: Add this when initializing kernel resources
 * This is a hack.
 */
void setup_idle_caps()
{
	struct capability *cap = &per_cpu(pmd_cap);
 
	cap_list_init(&current->cap_list);
	cap->type = CAP_RTYPE_MAPPOOL | CAP_TYPE_QUANTITY;
	cap->size = 50;
 
	link_init(&cap->list);
	cap_list_insert(cap, &current->cap_list);
}
 
/*
 * Set up current stack's beginning, and initial page tables
 * as a valid task environment for idle task for current cpu
 */
void setup_idle_task()
{
	memset(current, 0, sizeof(struct ktcb));
 
	current->space = &init_space;
	TASK_PGD(current) = &init_pgd;
 
	/* Initialize space caps list */
	cap_list_init(&current->space->cap_list);
 
	/*
	 * FIXME: This must go to kernel resources init.
	 */
 
	/* Init scheduler structs */
	sched_init_task(current, TASK_PRIO_NORMAL);
 
	/*
	 * If using split page tables, kernel
	 * resources must point at the global pgd
	 * TODO: We may need this for V6, in the future
	 */
#if defined(CONFIG_SUBARCH_V7)
	kernel_resources.pgd_global = &init_global_pgd;
#endif
}
 
void remove_initial_mapping(void)
{
	/* At this point, execution is on virtual addresses. */
	remove_section_mapping(virt_to_phys(_start_kernel));
}
 
void init_finalize(void)
{
	/* Set up idle task capabilities */
	setup_idle_caps();
 
	platform_timer_start();
 
#if defined (CONFIG_SMP)
	/* Tell other cores to continue */
	secondary_run_signal = 1;
	dmb();
#endif
 
	idle_task();
}
 
void start_kernel(void)
{
	print_early("\n"__KERNELNAME__": start kernel...\n");
 
	// print_sections();
 
	/* Early cpu initialization */
	cpu_startup();
 
	/*
	 * Initialise section mappings
	 * for the kernel area
	 */
	init_kernel_mappings();
 
	print_early("\n"__KERNELNAME__": Init kernel mappings...\n");
 
	/*
	 * Enable virtual memory
	 * and jump to virtual addresses
	 */
	start_virtual_memory();
 
	/*
	 * Set up initial page tables and ktcb
	 * as a valid environment for idle task
	 */
	setup_idle_task();
 
	/*
	 * Initialise platform-specific
	 * page mappings, and peripherals
	 */
	platform_init();
 
	/* Can only print when uart is mapped */
	printk("%s: Virtual memory enabled.\n",
	       __KERNELNAME__);
 
	/* Identify CPUs and system */
	system_identify();
 
	sched_init();
 
	/*
	 * Map and enable high vector page.
	 * Faults can be handled after here.
	 */
	vectors_init();
 
	/* Try to initialize secondary cores if there are any */
	smp_start_cores();
 
	/* Remove one-to-one kernel mapping */
	remove_initial_mapping();
 
	/* Remap 1MB kernel sections as 4Kb pages. */
	remap_as_pages((void *)page_align(_start_kernel),
		       (void *)page_align_up(_end_kernel));
 
	/*
	 * Initialise kip and map
	 * for userspace access
	 */
	kip_init();
 
	/* Initialise system call page */
	syscall_init();
 
	/* Init performance monitor, if enabled */
	perfmon_init();
 
	/*
	 * Evaluate system resources
	 * and set up resource pools
	 */
	init_system_resources(&kernel_resources);
 
	/*
	 * Free boot memory, switch to first
	 * task's stack and start scheduler
	 */
	init_finalize();
 
	BUG();
}