Merge branch 'rebase' of git://git.l4dev.org/~amit/codezero into amit

Conflicts:
	conts/baremetal/timer_service/main.c

conts/baremetal/clcd_service/SConstruct

@@ -0,0 +1,67 @@
+# -*- mode: python; coding: utf-8; -*-
+#
+#  Codezero -- Virtualization microkernel for embedded systems.
+#
+#  Copyright © 2009  B Labs Ltd
+#
+import os, shelve, sys
+from os.path import *
+
+PROJRELROOT = '../..'
+
+sys.path.append(PROJRELROOT)
+
+from config.projpaths import *
+from config.configuration import *
+
+config = configuration_retrieve()
+platform = config.platform
+arch = config.arch
+gcc_cpu_flag = config.gcc_cpu_flag
+
+LIBL4_RELDIR = 'conts/libl4'
+KERNEL_INCLUDE = join(PROJROOT, 'include')
+LIBL4_DIR = join(PROJROOT, LIBL4_RELDIR)
+LIBL4_INCLUDE = join(LIBL4_DIR, 'include')
+LIBL4_LIBPATH = join(BUILDDIR, LIBL4_RELDIR)
+
+# Locally important paths are here
+LIBC_RELDIR = 'conts/libc'
+LIBC_DIR = join(PROJROOT, LIBC_RELDIR)
+LIBC_LIBPATH = join(BUILDDIR, LIBC_RELDIR)
+LIBC_INCLUDE = [join(LIBC_DIR, 'include'), \
+                join(LIBC_DIR, 'include/arch' + '/' + arch)]
+
+LIBDEV_RELDIR = 'conts/libdev'
+LIBDEV_DIR = join(PROJROOT, LIBDEV_RELDIR)
+LIBDEV_LIBPATH = join(join(BUILDDIR, LIBDEV_RELDIR), 'sys-userspace')
+LIBDEV_INCLUDE = [join(LIBDEV_DIR, 'uart/include'),
+                  join(LIBDEV_DIR, 'clcd/pl110/include')]
+LIBDEV_CCFLAGS = '-DPLATFORM_' + platform.upper()
+
+# FIXME: Add these to autogenerated SConstruct !!!
+LIBMEM_RELDIR = 'conts/libmem'
+LIBMEM_DIR = join(PROJROOT, LIBMEM_RELDIR)
+LIBMEM_LIBPATH = join(BUILDDIR, LIBMEM_RELDIR)
+LIBMEM_INCLUDE = LIBMEM_DIR
+
+env = Environment(CC = config.user_toolchain + 'gcc',
+          # We don't use -nostdinc because sometimes we need standard headers,
+          # such as stdarg.h e.g. for variable args, as in printk().
+          CCFLAGS = ['-g', '-nostdlib', '-ffreestanding', '-std=gnu99', '-Wall', \
+                     '-Werror', ('-mcpu=' + gcc_cpu_flag), LIBDEV_CCFLAGS],
+          LINKFLAGS = ['-nostdlib', '-T' + "include/linker.lds", "-u_start"],
+		  ASFLAGS = ['-D__ASSEMBLY__'], \
+		  PROGSUFFIX = '.elf',			# The suffix to use for final executable\
+		  ENV = {'PATH' : os.environ['PATH']},	# Inherit shell path\
+		  LIBS = ['gcc', 'libl4', 'libmalloc', 'c-userspace', 'libdev-userspace', 'gcc', 'c-userspace'],	# libgcc.a - This is required for division routines.
+		  CPPPATH = ["#include", KERNEL_INCLUDE, LIBL4_INCLUDE, LIBDEV_INCLUDE, LIBC_INCLUDE, LIBMEM_INCLUDE],
+          LIBPATH = [LIBL4_LIBPATH, LIBDEV_LIBPATH, LIBC_LIBPATH, LIBMEM_LIBPATH],
+		  CPPFLAGS = '-include l4/config.h -include l4/macros.h -include l4/types.h')
+
+src = Glob('*.[cS]')
+src += Glob('src/*.[cS]')
+
+objs = env.Object(src)
+prog = env.Program('main.elf', objs)
+Depends(prog, 'include/linker.lds')

conts/baremetal/clcd_service/main.c

@@ -0,0 +1,277 @@
+/*
+ * CLCD service for userspace
+ */
+#include <l4lib/arch/syslib.h>
+#include <l4lib/arch/syscalls.h>
+#include <l4lib/addr.h>
+#include <l4lib/exregs.h>
+#include <l4lib/ipcdefs.h>
+#include <l4/api/errno.h>
+
+#include <l4/api/space.h>
+#include <capability.h>
+#include <container.h>
+#include <pl110_clcd.h>  /* FIXME: Its best if this is <libdev/uart/pl011.h> */
+#include <linker.h>
+
+#define CLCD_TOTAL		1
+
+static struct capability caparray[32];
+static int total_caps = 0;
+
+struct capability clcd_cap[CLCD_TOTAL];
+
+int cap_read_all()
+{
+	int ncaps;
+	int err;
+
+	/* Read number of capabilities */
+	if ((err = l4_capability_control(CAP_CONTROL_NCAPS,
+					 0, 0, 0, &ncaps)) < 0) {
+		printf("l4_capability_control() reading # of"
+		       " capabilities failed.\n Could not "
+		       "complete CAP_CONTROL_NCAPS request.\n");
+		BUG();
+	}
+	total_caps = ncaps;
+
+	/* Read all capabilities */
+	if ((err = l4_capability_control(CAP_CONTROL_READ,
+					 0, 0, 0, caparray)) < 0) {
+		printf("l4_capability_control() reading of "
+		       "capabilities failed.\n Could not "
+		       "complete CAP_CONTROL_READ_CAPS request.\n");
+		BUG();
+	}
+
+	return 0;
+}
+
+/*
+ * Scans for up to CLCD_TOTAL clcd devices in capabilities.
+ */
+int clcd_probe_devices(void)
+{
+	int clcds = 0;
+
+	/* Scan for clcd devices */
+	for (int i = 0; i < total_caps; i++) {
+		/* Match device type */
+		if (cap_devtype(&caparray[i]) == CAP_DEVTYPE_CLCD) {
+			/* Copy to correct device index */
+			memcpy(&clcd_cap[cap_devnum(&caparray[i])],
+			       &caparray[i], sizeof(clcd_cap[0]));
+			clcds++;
+		}
+	}
+
+	if (clcds != CLCD_TOTAL) {
+		printf("%s: Error, not all clcd could be found. "
+		       "total clcds=%d\n", __CONTAINER_NAME__, clcds);
+		return -ENODEV;
+	}
+	return 0;
+}
+
+/* 
+  * 1MB frame buffer,
+  * FIXME: can we do dma in this buffer?
+  */
+#define CLCD_FRAMEBUFFER_SZ	0x100000
+static char framebuffer[CLCD_FRAMEBUFFER_SZ];
+
+static struct pl110_clcd clcd[CLCD_TOTAL];
+
+int clcd_setup_devices(void)
+{
+	for (int i = 0; i < CLCD_TOTAL; i++) {
+		/* Get one page from address pool */
+		clcd[i].virt_base = (unsigned long)l4_new_virtual(1);
+
+		/* Map clcd to a virtual address region */
+		if (IS_ERR(l4_map((void *)__pfn_to_addr(clcd_cap[i].start),
+				  (void *)clcd[i].virt_base, clcd_cap[i].size,
+				  MAP_USR_IO_FLAGS,
+				  self_tid()))) {
+			printf("%s: FATAL: Failed to map CLCD device "
+			       "%d to a virtual address\n",
+			       __CONTAINER_NAME__,
+			       cap_devnum(&clcd_cap[i]));
+			BUG();
+		}
+
+		/* Initialize clcd */
+		pl110_initialise(&clcd[i], framebuffer);
+	}
+	return 0;
+}
+
+static struct address_pool device_vaddr_pool;
+
+/*
+ * Initialize a virtual address pool
+ * for mapping physical devices.
+ */
+void init_vaddr_pool(void)
+{
+	for (int i = 0; i < total_caps; i++) {
+		/* Find the virtual memory region for this process */
+		if (cap_type(&caparray[i]) == CAP_TYPE_MAP_VIRTMEM &&
+		    __pfn_to_addr(caparray[i].start) ==
+		    (unsigned long)vma_start) {
+
+			/*
+			 * Do we have any unused virtual space
+			 * where we run, and do we have enough
+			 * pages of it to map all clcd?
+			 */
+			if (__pfn(page_align_up(__end))
+			    + CLCD_TOTAL <= caparray[i].end) {
+				/*
+				 * Yes. We initialize the device
+				 * virtual memory pool here.
+				 *
+				 * We may allocate virtual memory
+				 * addresses from this pool.
+				 */
+				address_pool_init(&device_vaddr_pool,
+						  page_align_up(__end),
+						  __pfn_to_addr(caparray[i].end),
+						  CLCD_TOTAL);
+				return;
+			} else
+				goto out_err;
+		}
+	}
+
+out_err:
+	printf("%s: FATAL: No virtual memory "
+	       "region available to map "
+	       "devices.\n", __CONTAINER_NAME__);
+	BUG();
+}
+
+void *l4_new_virtual(int npages)
+{
+	return address_new(&device_vaddr_pool, npages, PAGE_SIZE);
+}
+
+void handle_requests(void)
+{
+	u32 mr[MR_UNUSED_TOTAL];
+	l4id_t senderid;
+	u32 tag;
+	int ret;
+
+	printf("%s: Initiating ipc.\n", __CONTAINER__);
+	if ((ret = l4_receive(L4_ANYTHREAD)) < 0) {
+		printf("%s: %s: IPC Error: %d. Quitting...\n",
+		       __CONTAINER__, __FUNCTION__, ret);
+		BUG();
+	}
+
+	/* Syslib conventional ipc data which uses first few mrs. */
+	tag = l4_get_tag();
+	senderid = l4_get_sender();
+
+	/* Read mrs not used by syslib */
+	for (int i = 0; i < MR_UNUSED_TOTAL; i++)
+		mr[i] = read_mr(MR_UNUSED_START + i);
+
+	/*
+	 * TODO:
+	 *
+	 * Maybe add tags here that handle requests for sharing
+	 * of the requested cld device with the client?
+	 *
+	 * In order to be able to do that, we should have a
+	 * shareable/grantable capability to the device. Also
+	 * the request should (currently) come from a task
+	 * inside the current container
+	 */
+
+	/*
+	  * FIXME: Right now we are talking to CLCD by default, we need to define protocol
+	  * for sommunication with CLCD service
+	  */
+	switch (tag) {
+
+	default:
+		printf("%s: Error received ipc from 0x%x residing "
+		       "in container %x with an unrecognized tag: "
+		       "0x%x\n", __CONTAINER__, senderid,
+		       __cid(senderid), tag);
+	}
+
+	/* Reply */
+	if ((ret = l4_ipc_return(ret)) < 0) {
+		printf("%s: IPC return error: %d.\n", __FUNCTION__, ret);
+		BUG();
+	}
+}
+
+/*
+ * UTCB-size aligned utcb.
+ *
+ * BIG WARNING NOTE:
+ * This in-place declaration is legal if we are running
+ * in a disjoint virtual address space, where the utcb
+ * declaration lies in a unique virtual address in
+ * the system.
+ */
+#define DECLARE_UTCB(name) \
+	struct utcb name ALIGN(sizeof(struct utcb))
+
+DECLARE_UTCB(utcb);
+
+/* Set up own utcb for ipc */
+int l4_utcb_setup(void *utcb_address)
+{
+	struct task_ids ids;
+	struct exregs_data exregs;
+	int err;
+
+	l4_getid(&ids);
+
+	/* Clear utcb */
+	memset(utcb_address, 0, sizeof(struct utcb));
+
+	/* Setup exregs for utcb request */
+	memset(&exregs, 0, sizeof(exregs));
+	exregs_set_utcb(&exregs, (unsigned long)utcb_address);
+
+	if ((err = l4_exchange_registers(&exregs, ids.tid)) < 0)
+		return err;
+
+	return 0;
+}
+
+void main(void)
+{
+	int err;
+
+	/* Read all capabilities */
+	cap_read_all();
+
+	/* Scan for clcd devices in capabilities */
+	clcd_probe_devices();
+
+	/* Initialize virtual address pool for clcds */
+	init_vaddr_pool();
+
+	/* Map and initialize clcd devices */
+	clcd_setup_devices();
+
+	/* Setup own utcb */
+	if ((err = l4_utcb_setup(&utcb)) < 0) {
+		printf("FATAL: Could not set up own utcb. "
+		       "err=%d\n", err);
+		BUG();
+	}
+
+	/* Listen for clcd requests */
+	while (1)
+		handle_requests();
+}
+

conts/baremetal/timer_service/include/timer.h

@@ -0,0 +1,36 @@
+#ifndef __TIMER_H__
+#define	__TIMER_H__
+
+/*
+ * Timer specific things are here
+ */
+#include <l4lib/mutex.h>
+#include <l4/lib/list.h>
+
+/*
+  * Structure representing the sleeping tasks, 
+  * tgid: tgid of sleeping task
+  * wait_count: time left, in microseconds, after which task
+  * 			will be signalled to get out of sleep
+  */
+struct timer_task {
+	struct link list;
+	l4id_t tgid;
+	unsigned int wait_count;
+};
+
+/*
+  * Timer structure,
+  * base: base address of sp804 timer encapsulated
+  * count: Count in microseconds from the start of this timer
+  * tasklist: list of tasks sleeping for some value of count
+  * lock: lock protecting the corruption of tasklist
+  */
+struct sp804_timer {
+	unsigned int base;
+	unsigned int count;
+	struct link tasklist;
+	struct l4_mutex lock;
+};
+
+#endif /* __TIMER_H__ */

conts/baremetal/timer_service/main.c

@@ -9,11 +9,12 @@
 #include <l4/api/errno.h>
 
 #include <l4/api/space.h>
+#include <malloc/malloc.h>
 #include <capability.h>
 #include <container.h>
 #include "sp804_timer.h"
 #include <linker.h>
-
+#include <timer.h>
 
 /* Frequency of timer in MHz */
 #define TIMER_FREQUENCY	1
@@ -188,16 +189,36 @@ int timer_probe_devices(void)
 
 static struct sp804_timer timer[TIMERS_TOTAL];
 
+struct timer_task *get_timer_task(l4id_t tgid)
+{
+	/* May be we can prepare a cache for timer_task structs */
+	struct timer_task *task = (struct timer_task *)kzalloc(sizeof(struct timer_task));
+
+	link_init(&task->list);
+	task->tgid = tgid;
+	task->wait_count = timer[0].count;
+
+	return task;
+}
+
+void free_timer_task(struct timer_task *task)
+{
+	kfree(task);
+}
+
 int timer_setup_devices(void)
 {
 	for (int i = 0; i < TIMERS_TOTAL; i++) {
 		/* Get one page from address pool */
 		timer[i].base = (unsigned long)l4_new_virtual(1);
+		timer[i].count = 0;
+		link_init(&timer[i].tasklist);
+		l4_mutex_init(&timer[i].lock);
 
 		/* Map timers to a virtual address region */
 		if (IS_ERR(l4_map((void *)__pfn_to_addr(timer_cap[i].start),
-				  	(void *)timer[i].base, timer_cap[i].size, MAP_USR_IO_FLAGS,
-				  	self_tid()))) {
+				  (void *)timer[i].base, timer_cap[i].size, MAP_USR_IO_FLAGS,
+				  self_tid()))) {
 			printf("%s: FATAL: Failed to map TIMER device "
 			       "%d to a virtual address\n",
 			       __CONTAINER_NAME__,
@@ -206,7 +227,7 @@ int timer_setup_devices(void)
 		}
 
 		/* Initialise timer */
-		sp804_init(timer[i].base, SP804_TIMER_RUNMODE_FREERUN, \
+		sp804_init(timer[i].base, SP804_TIMER_RUNMODE_PERIODIC, \
 			SP804_TIMER_WRAPMODE_WRAPPING, SP804_TIMER_WIDTH32BIT, \
 			SP804_TIMER_IRQDISABLE);
 
@@ -264,18 +285,48 @@ void *l4_new_virtual(int npages)
 	return address_new(&device_vaddr_pool, npages, PAGE_SIZE);
 }
 
-int timer_gettime(int devno)
+void timer_irq_handler(void)
 {
-	return sp804_read_value(timer[devno].base);
+	struct timer_task *struct_ptr, *temp_ptr;
+
+	timer[0].count += 1;
+
+	/*
+	 * FIXME:
+	 * Traverse through the sleeping process list and
+	 * wake any process if required, we need to put this part in bottom half
+	 */
+	list_foreach_removable_struct(struct_ptr, temp_ptr, &timer[0].tasklist, list)
+		if (struct_ptr->wait_count == timer[0].count) {
+
+			/* Remove task from list */
+			l4_mutex_lock(&timer[0].lock);
+			list_remove(&struct_ptr->list);
+			l4_mutex_unlock(&timer[0].lock);
+
+			/* wake the sleeping process, send wake ipc */
+
+			free_timer_task(struct_ptr);
+		}
 }
 
-void timer_sleep(int sec)
+int timer_gettime(void)
 {
-	/*
-	  * TODO: We need to have a timer struct already present to be used
-	  * as reference for us. to implement this call
-	  */
+	return timer[0].count;
 }
+
+void timer_sleep(l4id_t tgid, int sec)
+{
+	struct timer_task *task = get_timer_task(tgid);
+
+	/* Check for overflow */
+	task->wait_count += (sec * 1000000);
+
+	l4_mutex_lock(&timer[0].lock);
+	list_insert_tail(&task->list, &timer[0].tasklist);
+	l4_mutex_unlock(&timer[0].lock);
+}
+
 void handle_requests(void)
 {
 	u32 mr[MR_UNUSED_TOTAL];
@@ -311,11 +362,12 @@ void handle_requests(void)
 	 */
 	switch (tag) {
 	case L4_IPC_TAG_TIMER_GETTIME:
-		timer_gettime(1);
+		mr[0] = timer_gettime();
 		break;
 
 	case L4_IPC_TAG_TIMER_SLEEP:
-		timer_sleep(mr[0]);
+		timer_sleep(senderid, mr[0]);
+		/* TODO: Halt the caller for mr[0] seconds */
 		break;
 
 	default:

conts/baremetal/uart_service/container.c

@@ -0,0 +1,21 @@
+/*
+ * Container entry point for pager
+ *
+ * Copyright (C) 2007-2009 B Labs Ltd.
+ */
+
+#include <l4lib/init.h>
+#include <l4lib/utcb.h>
+
+
+extern void main(void);
+
+void __container_init(void)
+{
+	/* Generic L4 initialisation */
+	__l4_init();
+
+	/* Entry to main */
+	main();
+}
+

conts/baremetal/uart_service/include/capability.h

@@ -0,0 +1,12 @@
+#ifndef __UART_SERVICE_CAPABILITY_H__
+#define __UART_SERVICE_CAPABILITY_H__
+
+#include <l4lib/capability.h>
+#include <l4/api/capability.h>
+#include <l4/generic/cap-types.h>
+
+void cap_print(struct capability *cap);
+void cap_list_print(struct cap_list *cap_list);
+int cap_read_all();
+
+#endif /* header */

conts/baremetal/uart_service/include/container.h

@@ -0,0 +1,13 @@
+/*
+ * Autogenerated definitions for this container.
+ */
+#ifndef __CONTAINER_H__
+#define __CONTAINER_H__
+
+
+#define __CONTAINER_NAME__	"uart_service"
+#define __CONTAINER_ID__	0
+#define __CONTAINER__		"cont0"
+
+
+#endif /* __CONTAINER_H__ */

conts/baremetal/uart_service/include/linker.h

@@ -0,0 +1,7 @@
+#ifndef __LINKER_H__
+#define __LINKER_H__
+
+extern char vma_start[];
+extern char __end[];
+
+#endif /* __LINKER_H__ */