Index: kernel/arch/amd64/src/debugger.c
===================================================================
--- kernel/arch/amd64/src/debugger.c	(revision 8fe5980e42d82b7d2d7e089fc06a6048def9ee08)
+++ kernel/arch/amd64/src/debugger.c	(revision 5ae44434cfd2872a471686a96b90a32837daa999)
@@ -55,4 +55,6 @@
 SPINLOCK_INITIALIZE(bkpoint_lock);
 
+#ifdef CONFIG_KCONSOLE
+
 static int cmd_print_breakpoints(cmd_arg_t *argv);
 static cmd_info_t bkpts_info = {
@@ -100,41 +102,6 @@
 };
 
-#endif
-
-/** Print table of active breakpoints */
-int cmd_print_breakpoints(cmd_arg_t *argv __attribute__((unused)))
-{
-	unsigned int i;
-	char *symbol;
-
-#ifdef __32_BITS__	
-	printf("#  Count Address    In symbol\n");
-	printf("-- ----- ---------- ---------\n");
-#endif
-
-#ifdef __64_BITS__
-	printf("#  Count Address            In symbol\n");
-	printf("-- ----- ------------------ ---------\n");
-#endif
-	
-	for (i = 0; i < BKPOINTS_MAX; i++)
-		if (breakpoints[i].address) {
-			symbol = get_symtab_entry(breakpoints[i].address);
-
-#ifdef __32_BITS__
-			printf("%-2u %-5d %#10zx %s\n", i,
-			    breakpoints[i].counter, breakpoints[i].address,
-			    symbol);
-#endif
-
-#ifdef __64_BITS__
-			printf("%-2u %-5d %#18zx %s\n", i,
-			    breakpoints[i].counter, breakpoints[i].address,
-			    symbol);
-#endif
-
-		}
-	return 1;
-}
+#endif /* CONFIG_DEBUG_AS_WATCHPOINT */
+#endif /* CONFIG_KCONSOLE */
 
 /* Setup DR register according to table */
@@ -268,8 +235,10 @@
 	printf("Reached breakpoint %d:%lx(%s)\n", slot, getip(istate),
 	    get_symtab_entry(getip(istate)));
-	printf("***Type 'exit' to exit kconsole.\n");
-	atomic_set(&haltstate,1);
-	kconsole((void *) "debug");
-	atomic_set(&haltstate,0);
+
+#ifdef CONFIG_KCONSOLE
+	atomic_set(&haltstate, 1);
+	kconsole("debug", "Debug console ready (type 'exit' to continue)\n", false);
+	atomic_set(&haltstate, 0);
+#endif
 }
 
@@ -300,39 +269,5 @@
 }
 
-#ifndef CONFIG_DEBUG_AS_WATCHPOINT
-
-/** Remove breakpoint from table */
-int cmd_del_breakpoint(cmd_arg_t *argv)
-{
-	unative_t bpno = argv->intval;
-	if (bpno > BKPOINTS_MAX) {
-		printf("Invalid breakpoint number.\n");
-		return 0;
-	}
-	breakpoint_del(argv->intval);
-	return 1;
-}
-
-/** Add new breakpoint to table */
-static int cmd_add_breakpoint(cmd_arg_t *argv)
-{
-	int flags;
-	int id;
-
-	if (argv == &add_argv) {
-		flags = BKPOINT_INSTR;
-	} else { /* addwatchp */
-		flags = BKPOINT_WRITE;
-	}
-	printf("Adding breakpoint on address: %p\n", argv->intval);
-	id = breakpoint_add((void *)argv->intval, flags, -1);
-	if (id < 0)
-		printf("Add breakpoint failed.\n");
-	else
-		printf("Added breakpoint %d.\n", id);
-	
-	return 1;
-}
-#endif
+
 
 static void debug_exception(int n __attribute__((unused)), istate_t *istate)
@@ -380,22 +315,24 @@
 	for (i = 0; i < BKPOINTS_MAX; i++)
 		breakpoints[i].address = NULL;
-	
+
+#ifdef CONFIG_KCONSOLE
 	cmd_initialize(&bkpts_info);
 	if (!cmd_register(&bkpts_info))
-		panic("could not register command %s\n", bkpts_info.name);
+		printf("Cannot register command %s\n", bkpts_info.name);
 
 #ifndef CONFIG_DEBUG_AS_WATCHPOINT
 	cmd_initialize(&delbkpt_info);
 	if (!cmd_register(&delbkpt_info))
-		panic("could not register command %s\n", delbkpt_info.name);
+		printf("Cannot register command %s\n", delbkpt_info.name);
 
 	cmd_initialize(&addbkpt_info);
 	if (!cmd_register(&addbkpt_info))
-		panic("could not register command %s\n", addbkpt_info.name);
+		printf("Cannot register command %s\n", addbkpt_info.name);
 
 	cmd_initialize(&addwatchp_info);
 	if (!cmd_register(&addwatchp_info))
-		panic("could not register command %s\n", addwatchp_info.name);
-#endif
+		printf("Cannot register command %s\n", addwatchp_info.name);
+#endif /* CONFIG_DEBUG_AS_WATCHPOINT */
+#endif /* CONFIG_KCONSOLE */
 	
 	exc_register(VECTOR_DEBUG, "debugger", debug_exception);
@@ -405,4 +342,78 @@
 }
 
+#ifdef CONFIG_KCONSOLE
+/** Print table of active breakpoints */
+int cmd_print_breakpoints(cmd_arg_t *argv __attribute__((unused)))
+{
+	unsigned int i;
+	char *symbol;
+
+#ifdef __32_BITS__	
+	printf("#  Count Address    In symbol\n");
+	printf("-- ----- ---------- ---------\n");
+#endif
+
+#ifdef __64_BITS__
+	printf("#  Count Address            In symbol\n");
+	printf("-- ----- ------------------ ---------\n");
+#endif
+	
+	for (i = 0; i < BKPOINTS_MAX; i++)
+		if (breakpoints[i].address) {
+			symbol = get_symtab_entry(breakpoints[i].address);
+
+#ifdef __32_BITS__
+			printf("%-2u %-5d %#10zx %s\n", i,
+			    breakpoints[i].counter, breakpoints[i].address,
+			    symbol);
+#endif
+
+#ifdef __64_BITS__
+			printf("%-2u %-5d %#18zx %s\n", i,
+			    breakpoints[i].counter, breakpoints[i].address,
+			    symbol);
+#endif
+
+		}
+	return 1;
+}
+
+#ifndef CONFIG_DEBUG_AS_WATCHPOINT
+
+/** Remove breakpoint from table */
+int cmd_del_breakpoint(cmd_arg_t *argv)
+{
+	unative_t bpno = argv->intval;
+	if (bpno > BKPOINTS_MAX) {
+		printf("Invalid breakpoint number.\n");
+		return 0;
+	}
+	breakpoint_del(argv->intval);
+	return 1;
+}
+
+/** Add new breakpoint to table */
+static int cmd_add_breakpoint(cmd_arg_t *argv)
+{
+	int flags;
+	int id;
+
+	if (argv == &add_argv) {
+		flags = BKPOINT_INSTR;
+	} else { /* addwatchp */
+		flags = BKPOINT_WRITE;
+	}
+	printf("Adding breakpoint on address: %p\n", argv->intval);
+	id = breakpoint_add((void *)argv->intval, flags, -1);
+	if (id < 0)
+		printf("Add breakpoint failed.\n");
+	else
+		printf("Added breakpoint %d.\n", id);
+	
+	return 1;
+}
+#endif /* CONFIG_DEBUG_AS_WATCHPOINT */
+#endif /* CONFIG_KCONSOLE */
+
 /** @}
  */
Index: kernel/arch/ia32/include/drivers/ega.h
===================================================================
--- kernel/arch/ia32/include/drivers/ega.h	(revision 8fe5980e42d82b7d2d7e089fc06a6048def9ee08)
+++ kernel/arch/ia32/include/drivers/ega.h	(revision 5ae44434cfd2872a471686a96b90a32837daa999)
@@ -41,4 +41,5 @@
 #define SCREEN		(ROW * ROWS)
 
+extern void ega_redraw(void);
 extern void ega_init(void);
 
Index: kernel/arch/ia32/include/drivers/vesa.h
===================================================================
--- kernel/arch/ia32/include/drivers/vesa.h	(revision 8fe5980e42d82b7d2d7e089fc06a6048def9ee08)
+++ kernel/arch/ia32/include/drivers/vesa.h	(revision 5ae44434cfd2872a471686a96b90a32837daa999)
@@ -37,4 +37,5 @@
 
 extern int vesa_present(void);
+extern void vesa_redraw(void);
 extern void vesa_init(void);
 
Index: kernel/arch/ia32/src/cpu/cpu.c
===================================================================
--- kernel/arch/ia32/src/cpu/cpu.c	(revision 8fe5980e42d82b7d2d7e089fc06a6048def9ee08)
+++ kernel/arch/ia32/src/cpu/cpu.c	(revision 5ae44434cfd2872a471686a96b90a32837daa999)
@@ -66,6 +66,6 @@
 static char *vendor_str[] = {
 	"Unknown Vendor",
-	"AuthenticAMD",
-	"GenuineIntel"
+	"AMD",
+	"Intel"
 };
 
@@ -78,5 +78,5 @@
 		:
 		:
-		:"%eax"
+		: "%eax"
 	);
 }
@@ -90,5 +90,5 @@
 		:
 		:
-		:"%eax"
+		: "%eax"
 	);	
 }
@@ -141,27 +141,29 @@
 		 * Check for AMD processor.
 		 */
-		if (info.cpuid_ebx==AMD_CPUID_EBX && info.cpuid_ecx==AMD_CPUID_ECX && info.cpuid_edx==AMD_CPUID_EDX) {
+		if ((info.cpuid_ebx == AMD_CPUID_EBX)
+		    && (info.cpuid_ecx == AMD_CPUID_ECX)
+			&& (info.cpuid_edx == AMD_CPUID_EDX))
 			CPU->arch.vendor = VendorAMD;
-		}
-
+		
 		/*
 		 * Check for Intel processor.
 		 */		
-		if (info.cpuid_ebx==INTEL_CPUID_EBX && info.cpuid_ecx==INTEL_CPUID_ECX && info.cpuid_edx==INTEL_CPUID_EDX) {
+		if ((info.cpuid_ebx == INTEL_CPUID_EBX)
+		    && (info.cpuid_ecx == INTEL_CPUID_ECX)
+			&& (info.cpuid_edx == INTEL_CPUID_EDX))
 			CPU->arch.vendor = VendorIntel;
-		}
-				
+		
 		cpuid(1, &info);
-		CPU->arch.family = (info.cpuid_eax>>8)&0xf;
-		CPU->arch.model = (info.cpuid_eax>>4)&0xf;
-		CPU->arch.stepping = (info.cpuid_eax>>0)&0xf;						
+		CPU->arch.family = (info.cpuid_eax >> 8) & 0x0f;
+		CPU->arch.model = (info.cpuid_eax >> 4) & 0x0f;
+		CPU->arch.stepping = (info.cpuid_eax >> 0) & 0x0f;						
 	}
 }
 
-void cpu_print_report(cpu_t* m)
+void cpu_print_report(cpu_t* cpu)
 {
-	printf("cpu%d: (%s family=%d model=%d stepping=%d) %dMHz\n",
-		m->id, vendor_str[m->arch.vendor], m->arch.family, m->arch.model, m->arch.stepping,
-		m->frequency_mhz);
+	printf("cpu%u: (%s family=%u model=%u stepping=%u) %" PRIu16 " MHz\n",
+		cpu->id, vendor_str[cpu->arch.vendor], cpu->arch.family,
+		cpu->arch.model, cpu->arch.stepping, cpu->frequency_mhz);
 }
 
Index: kernel/arch/ia32/src/drivers/vesa.c
===================================================================
--- kernel/arch/ia32/src/drivers/vesa.c	(revision 8fe5980e42d82b7d2d7e089fc06a6048def9ee08)
+++ kernel/arch/ia32/src/drivers/vesa.c	(revision 5ae44434cfd2872a471686a96b90a32837daa999)
@@ -98,4 +98,9 @@
 }
 
+void vesa_redraw(void)
+{
+	fb_redraw();
+}
+
 #endif
 
Index: kernel/arch/ia32/src/ia32.c
===================================================================
--- kernel/arch/ia32/src/ia32.c	(revision 8fe5980e42d82b7d2d7e089fc06a6048def9ee08)
+++ kernel/arch/ia32/src/ia32.c	(revision 5ae44434cfd2872a471686a96b90a32837daa999)
@@ -94,5 +94,5 @@
 		else
 #endif
-			ega_init();	/* video */
+			ega_init(); /* video */
 		
 		/* Enable debugger */
@@ -160,6 +160,13 @@
 void arch_grab_console(void)
 {
+#ifdef CONFIG_FB
+	vesa_redraw();
+#else
+	ega_redraw();
+#endif
+	
 	i8042_grab();
 }
+
 /** Return console to userspace
  *
Index: kernel/arch/mips32/src/cpu/cpu.c
===================================================================
--- kernel/arch/mips32/src/cpu/cpu.c	(revision 8fe5980e42d82b7d2d7e089fc06a6048def9ee08)
+++ kernel/arch/mips32/src/cpu/cpu.c	(revision 5ae44434cfd2872a471686a96b90a32837daa999)
@@ -49,5 +49,5 @@
 	{ "MIPS", "R3000" },		/* 0x02 */
 	{ "MIPS", "R6000" },		/* 0x03 */
-	{ "MIPS", " R4000/R4400" }, 	/* 0x04 */
+	{ "MIPS", "R4000/R4400" }, 	/* 0x04 */
 	{ "LSI Logic", "R3000" },	/* 0x05 */
 	{ "MIPS", "R6000A" },		/* 0x06 */
@@ -124,7 +124,7 @@
 	}
 
-	printf("cpu%d: %s %s (rev=%d.%d, imp=%d)\n",
+	printf("cpu%u: %s %s (rev=%d.%d, imp=%d)\n",
 		m->id, data->vendor, data->model, m->arch.rev_num >> 4, 
-		m->arch.rev_num & 0xf, m->arch.imp_num);
+		m->arch.rev_num & 0x0f, m->arch.imp_num);
 }
 
Index: kernel/arch/mips32/src/debugger.c
===================================================================
--- kernel/arch/mips32/src/debugger.c	(revision 8fe5980e42d82b7d2d7e089fc06a6048def9ee08)
+++ kernel/arch/mips32/src/debugger.c	(revision 5ae44434cfd2872a471686a96b90a32837daa999)
@@ -47,4 +47,6 @@
 bpinfo_t breakpoints[BKPOINTS_MAX];
 SPINLOCK_INITIALIZE(bkpoint_lock);
+
+#ifdef CONFIG_KCONSOLE
 
 static int cmd_print_breakpoints(cmd_arg_t *argv);
@@ -124,8 +126,10 @@
 };
 
+
 /** Test, if the given instruction is a jump or branch instruction
  *
  * @param instr Instruction code
  * @return true - it is jump instruction, false otherwise
+ *
  */
 static bool is_jump(unative_t instr)
@@ -268,4 +272,6 @@
 }
 
+#endif
+
 /** Initialize debugger */
 void debugger_init()
@@ -275,20 +281,22 @@
 	for (i = 0; i < BKPOINTS_MAX; i++)
 		breakpoints[i].address = NULL;
-	
+
+#ifdef CONFIG_KCONSOLE
 	cmd_initialize(&bkpts_info);
 	if (!cmd_register(&bkpts_info))
-		panic("could not register command %s\n", bkpts_info.name);
+		printf("Cannot register command %s\n", bkpts_info.name);
 
 	cmd_initialize(&delbkpt_info);
 	if (!cmd_register(&delbkpt_info))
-		panic("could not register command %s\n", delbkpt_info.name);
+		printf("Cannot register command %s\n", delbkpt_info.name);
 
 	cmd_initialize(&addbkpt_info);
 	if (!cmd_register(&addbkpt_info))
-		panic("could not register command %s\n", addbkpt_info.name);
+		printf("Cannot register command %s\n", addbkpt_info.name);
 
 	cmd_initialize(&addbkpte_info);
 	if (!cmd_register(&addbkpte_info))
-		panic("could not register command %s\n", addbkpte_info.name);
+		printf("Cannot register command %s\n", addbkpte_info.name);
+#endif
 }
 
@@ -368,5 +376,5 @@
 			cur->bkfunc(cur, istate);
 	} else {
-		printf("***Type 'exit' to exit kconsole.\n");
+#ifdef CONFIG_KCONSOLE
 		/* This disables all other processors - we are not SMP,
 		 * actually this gets us to cpu_halt, if scheduler() is run
@@ -374,11 +382,12 @@
 		 *   so this is a good idea
 		 */	
-		atomic_set(&haltstate,1);
+		atomic_set(&haltstate, 1);
 		spinlock_unlock(&bkpoint_lock);
-
-		kconsole("debug");
-
+		
+		kconsole("debug", "Debug console ready (type 'exit' to continue)\n", false);
+		
 		spinlock_lock(&bkpoint_lock);
-		atomic_set(&haltstate,0);
+		atomic_set(&haltstate, 0);
+#endif
 	}
 	if (cur && cur->address == fireaddr && (cur->flags & BKPOINT_INPROG)) {
Index: kernel/arch/mips32/src/exception.c
===================================================================
--- kernel/arch/mips32/src/exception.c	(revision 8fe5980e42d82b7d2d7e089fc06a6048def9ee08)
+++ kernel/arch/mips32/src/exception.c	(revision 5ae44434cfd2872a471686a96b90a32837daa999)
@@ -46,5 +46,4 @@
 #include <interrupt.h>
 #include <func.h>
-#include <console/kconsole.h>
 #include <ddi/irq.h>
 #include <arch/debugger.h>
Index: kernel/genarch/include/fb/fb.h
===================================================================
--- kernel/genarch/include/fb/fb.h	(revision 8fe5980e42d82b7d2d7e089fc06a6048def9ee08)
+++ kernel/genarch/include/fb/fb.h	(revision 5ae44434cfd2872a471686a96b90a32837daa999)
@@ -27,5 +27,5 @@
  */
 
-/** @addtogroup genarch	
+/** @addtogroup genarch
  * @{
  */
@@ -66,4 +66,6 @@
 
 SPINLOCK_EXTERN(fb_lock);
+
+void fb_redraw(void);
 void fb_init(fb_properties_t *props);
 
Index: kernel/genarch/include/fb/font-8x16.h
===================================================================
--- kernel/genarch/include/fb/font-8x16.h	(revision 8fe5980e42d82b7d2d7e089fc06a6048def9ee08)
+++ kernel/genarch/include/fb/font-8x16.h	(revision 5ae44434cfd2872a471686a96b90a32837daa999)
@@ -27,5 +27,5 @@
  */
 
-/** @addtogroup genarch	
+/** @addtogroup genarch
  * @{
  */
@@ -36,8 +36,11 @@
 #define KERN_FONT_8X16_H_
 
-#define FONT_GLIPHS		256
-#define FONT_SCANLINES	16
+#define FONT_GLYPHS      256
+#define FONT_WIDTH       8
+#define FONT_SCANLINES   16
 
-extern unsigned char fb_font[FONT_GLIPHS * FONT_SCANLINES];
+#include <arch/types.h>
+
+extern uint8_t fb_font[FONT_GLYPHS * FONT_SCANLINES];
 
 #endif
Index: kernel/genarch/include/fb/visuals.h
===================================================================
--- kernel/genarch/include/fb/visuals.h	(revision 8fe5980e42d82b7d2d7e089fc06a6048def9ee08)
+++ kernel/genarch/include/fb/visuals.h	(revision 5ae44434cfd2872a471686a96b90a32837daa999)
@@ -27,5 +27,5 @@
  */
 
-/** @addtogroup genarch	
+/** @addtogroup genarch
  * @{
  */
@@ -36,13 +36,13 @@
 #define KERN_VISUALS_H_
 
-#define VISUAL_INDIRECT_8	0
+#define VISUAL_INDIRECT_8   0
 
-#define VISUAL_RGB_5_5_5	1
-#define VISUAL_RGB_5_6_5	2
-#define VISUAL_RGB_8_8_8	3
-#define VISUAL_RGB_8_8_8_0	4
-#define VISUAL_RGB_0_8_8_8	5
+#define VISUAL_RGB_5_5_5    1
+#define VISUAL_RGB_5_6_5    2
+#define VISUAL_RGB_8_8_8    3
+#define VISUAL_RGB_8_8_8_0  4
+#define VISUAL_RGB_0_8_8_8  5
 
-#define VISUAL_BGR_0_8_8_8	6
+#define VISUAL_BGR_0_8_8_8  6
 
 #endif
Index: kernel/genarch/src/acpi/acpi.c
===================================================================
--- kernel/genarch/src/acpi/acpi.c	(revision 8fe5980e42d82b7d2d7e089fc06a6048def9ee08)
+++ kernel/genarch/src/acpi/acpi.c	(revision 5ae44434cfd2872a471686a96b90a32837daa999)
@@ -50,6 +50,10 @@
 struct acpi_xsdt *acpi_xsdt = NULL;
 
-struct acpi_signature_map signature_map[] = { 
-	{ (uint8_t *)"APIC", (void *) &acpi_madt, "Multiple APIC Description Table" }
+struct acpi_signature_map signature_map[] = {
+	{
+		(uint8_t *) "APIC",
+		(void *) &acpi_madt,
+		"Multiple APIC Description Table"
+	}
 };
 
@@ -106,5 +110,5 @@
 					goto next;
 				*signature_map[j].sdt_ptr = h;
-				printf("%p: ACPI %s\n", *signature_map[j].sdt_ptr, signature_map[j].description);
+				LOG("%p: ACPI %s\n", *signature_map[j].sdt_ptr, signature_map[j].description);
 			}
 		}
@@ -127,5 +131,5 @@
 					goto next;
 				*signature_map[j].sdt_ptr = h;
-				printf("%p: ACPI %s\n", *signature_map[j].sdt_ptr, signature_map[j].description);
+				LOG("%p: ACPI %s\n", *signature_map[j].sdt_ptr, signature_map[j].description);
 			}
 		}
@@ -161,5 +165,5 @@
 
 rsdp_found:
-	printf("%p: ACPI Root System Description Pointer\n", acpi_rsdp);
+	LOG("%p: ACPI Root System Description Pointer\n", acpi_rsdp);
 
 	acpi_rsdt = (struct acpi_rsdt *) (unative_t) acpi_rsdp->rsdt_address;
Index: kernel/genarch/src/fb/fb.c
===================================================================
--- kernel/genarch/src/fb/fb.c	(revision 8fe5980e42d82b7d2d7e089fc06a6048def9ee08)
+++ kernel/genarch/src/fb/fb.c	(revision 5ae44434cfd2872a471686a96b90a32837daa999)
@@ -1,3 +1,4 @@
 /*
+ * Copyright (c) 2008 Martin Decky
  * Copyright (c) 2006 Ondrej Palkovsky
  * All rights reserved.
@@ -27,5 +28,5 @@
  */
 
-/** @addtogroup genarch	
+/** @addtogroup genarch
  * @{
  */
@@ -40,4 +41,5 @@
 #include <sysinfo/sysinfo.h>
 #include <mm/slab.h>
+#include <align.h>
 #include <panic.h>
 #include <memstr.h>
@@ -48,135 +50,107 @@
 #include <arch/types.h>
 
-#include "helenos.xbm"
-
-static parea_t fb_parea;		/**< Physical memory area for fb. */
-
 SPINLOCK_INITIALIZE(fb_lock);
 
-static uint8_t *fbaddress = NULL;
-
-static uint8_t *blankline = NULL;
-static uint8_t *dbbuffer = NULL;	/* Buffer for fast scrolling console */
-static index_t dboffset;
-
-static unsigned int xres = 0;
-static unsigned int yres = 0;
-static unsigned int scanline = 0;
-static unsigned int pixelbytes = 0;
-#ifdef FB_INVERT_COLORS
-static bool invert_colors = true;
+/**< Physical memory area for fb. */
+static parea_t fb_parea;
+
+static uint8_t *fb_addr;
+static uint8_t *backbuf;
+static uint8_t *glyphs;
+
+static void *bgpixel;
+
+static unsigned int xres;
+static unsigned int yres;
+
+static unsigned int scanline;
+static unsigned int glyphscanline;
+
+static unsigned int pixelbytes;
+static unsigned int glyphbytes;
+
+static unsigned int cols;
+static unsigned int rows;
+static unsigned int position = 0;
+
+#define BG_COLOR     0x000080
+#define FG_COLOR     0xffff00
+
+#define CURSOR       219
+
+#define RED(x, bits)         ((x >> (8 + 8 + 8 - bits)) & ((1 << bits) - 1))
+#define GREEN(x, bits)       ((x >> (8 + 8 - bits)) & ((1 << bits) - 1))
+#define BLUE(x, bits)        ((x >> (8 - bits)) & ((1 << bits) - 1))
+
+#define COL2X(col)           ((col) * FONT_WIDTH)
+#define ROW2Y(row)           ((row) * FONT_SCANLINES)
+
+#define X2COL(x)             ((x) / FONT_WIDTH)
+#define Y2ROW(y)             ((y) / FONT_SCANLINES)
+
+#define FB_POS(x, y)         ((y) * scanline + (x) * pixelbytes)
+#define BB_POS(col, row)     ((row) * cols + (col))
+#define GLYPH_POS(glyph, y)  ((glyph) * glyphbytes + (y) * glyphscanline)
+
+
+static void (*rgb_conv)(void *, uint32_t);
+
+
+/** ARGB 8:8:8:8 conversion
+ *
+ */
+static void rgb_0888(void *dst, uint32_t rgb)
+{
+	*((uint32_t *) dst) = rgb & 0xffffff;
+}
+
+
+/** ABGR 8:8:8:8 conversion
+ *
+ */
+static void bgr_0888(void *dst, uint32_t rgb)
+{
+	*((uint32_t *) dst)
+	    = (BLUE(rgb, 8) << 16) | (GREEN(rgb, 8) << 8) | RED(rgb, 8);
+}
+
+
+/** BGR 8:8:8 conversion
+ *
+ */
+static void rgb_888(void *dst, uint32_t rgb)
+{
+#if defined(FB_INVERT_ENDIAN)
+	*((uint32_t *) dst)
+	    = (BLUE(rgb, 8) << 16) | (GREEN(rgb, 8) << 8) | RED(rgb, 8)
+	    | (*((uint32_t *) dst) & 0xff0000);
 #else
-static bool invert_colors = false;
+	*((uint32_t *) dst)
+	    = (rgb & 0xffffff) | (*((uint32_t *) dst) & 0xff0000);
 #endif
-
-static unsigned int position = 0;
-static unsigned int columns = 0;
-static unsigned int rows = 0;
-
-#define COL_WIDTH	8
-#define ROW_BYTES	(scanline * FONT_SCANLINES)
-
-#define BGCOLOR		0x000080
-#define FGCOLOR		0xffff00
-#define LOGOCOLOR	0x2020b0
-
-#define RED(x, bits)	((x >> (8 + 8 + 8 - bits)) & ((1 << bits) - 1))
-#define GREEN(x, bits)	((x >> (8 + 8 - bits)) & ((1 << bits) - 1))
-#define BLUE(x, bits)	((x >> (8 - bits)) & ((1 << bits) - 1))
-
-#define POINTPOS(x, y)	((y) * scanline + (x) * pixelbytes)
-
-/***************************************************************/
-/* Pixel specific fuctions */
-
-static void (*rgb2scr)(void *, int);
-static int (*scr2rgb)(void *);
-
-static inline int COLOR(int color)
-{
-	return invert_colors ? ~color : color;
-}
-
-/* Conversion routines between different color representations */
-static void rgb_byte0888(void *dst, int rgb)
-{
-	*((int *) dst) = rgb;
-}
-
-static int byte0888_rgb(void *src)
-{
-	return (*((int *) src)) & 0xffffff;
-}
-
-static void bgr_byte0888(void *dst, int rgb)
-{
-	*((uint32_t *) dst) = BLUE(rgb, 8) << 16 | GREEN(rgb, 8) << 8 |
-	    RED(rgb, 8);
-}
-
-static int byte0888_bgr(void *src)
-{
-	int color = *(uint32_t *)(src);
-	return ((color & 0xff) << 16) | (((color >> 8) & 0xff) << 8) |
-	    ((color >> 16) & 0xff);
-}
-
-static void rgb_byte888(void *dst, int rgb)
-{
-	uint8_t *scr = (uint8_t *) dst;
-#if defined(FB_INVERT_ENDIAN)
-	scr[0] = RED(rgb, 8);
-	scr[1] = GREEN(rgb, 8);
-	scr[2] = BLUE(rgb, 8);
-#else
-	scr[2] = RED(rgb, 8);
-	scr[1] = GREEN(rgb, 8);
-	scr[0] = BLUE(rgb, 8);
-#endif
-}
-
-static int byte888_rgb(void *src)
-{
-	uint8_t *scr = (uint8_t *) src;
-#if defined(FB_INVERT_ENDIAN)
-	return scr[0] << 16 | scr[1] << 8 | scr[2];
-#else
-	return scr[2] << 16 | scr[1] << 8 | scr[0];
-#endif	
-}
-
-/**  16-bit depth (5:5:5) */
-static void rgb_byte555(void *dst, int rgb)
-{
-	/* 5-bit, 5-bits, 5-bits */ 
-	*((uint16_t *) dst) = RED(rgb, 5) << 10 | GREEN(rgb, 5) << 5 |
-	    BLUE(rgb, 5);
-}
-
-/** 16-bit depth (5:5:5) */
-static int byte555_rgb(void *src)
-{
-	int color = *(uint16_t *)(src);
-	return (((color >> 10) & 0x1f) << (16 + 3)) |
-	    (((color >> 5) & 0x1f) << (8 + 3)) | ((color & 0x1f) << 3);
-}
-
-/**  16-bit depth (5:6:5) */
-static void rgb_byte565(void *dst, int rgb)
-{
-	/* 5-bit, 6-bits, 5-bits */ 
-	*((uint16_t *) dst) = RED(rgb, 5) << 11 | GREEN(rgb, 6) << 5 |
-	    BLUE(rgb, 5);
-}
-
-/** 16-bit depth (5:6:5) */
-static int byte565_rgb(void *src)
-{
-	int color = *(uint16_t *)(src);
-	return (((color >> 11) & 0x1f) << (16 + 3)) |
-	    (((color >> 5) & 0x3f) << (8 + 2)) | ((color & 0x1f) << 3);
-}
-
-/** Put pixel - 8-bit depth (color palette/3:2:3, inverted)
+}
+
+
+/** RGB 5:5:5 conversion
+ *
+ */
+static void rgb_555(void *dst, uint32_t rgb)
+{
+	*((uint16_t *) dst)
+	    = (RED(rgb, 5) << 10) | (GREEN(rgb, 5) << 5) | BLUE(rgb, 5);
+}
+
+
+/** RGB 5:6:5 conversion
+ *
+ */
+static void rgb_565(void *dst, uint32_t rgb)
+{
+	*((uint16_t *) dst)
+	    = (RED(rgb, 5) << 11) | (GREEN(rgb, 6) << 5) | BLUE(rgb, 5);
+}
+
+
+/** RGB 3:2:3
  *
  * Even though we try 3:2:3 color scheme here, an 8-bit framebuffer
@@ -186,5 +160,5 @@
  * and setting it to simulate the 8-bit truecolor.
  *
- * Currently we set the palette on the sparc64 port.
+ * Currently we set the palette on the ia32 and sparc64 port.
  *
  * Note that the byte is being inverted by this function. The reason is
@@ -194,205 +168,82 @@
  * 0 and 255 to other colors.
  */
-static void rgb_byte8(void *dst, int rgb)
-{
-	*((uint8_t *) dst) = 255 - (RED(rgb, 3) << 5 | GREEN(rgb, 2) << 3 |
-	    BLUE(rgb, 3));
-}
-
-/** Return pixel color - 8-bit depth (color palette/3:2:3)
- *
- * See the comment for rgb_byte().
- */
-static int byte8_rgb(void *src)
-{
-	int color = 255 - (*(uint8_t *)src);
-	return (((color >> 5) & 0x7) << (16 + 5)) |
-	    (((color >> 3) & 0x3) << (8 + 6)) | ((color & 0x7) << 5);
-}
-
-static void putpixel(unsigned int x, unsigned int y, int color)
-{
-	(*rgb2scr)(&fbaddress[POINTPOS(x, y)], COLOR(color));
-
-	if (dbbuffer) {
-		int dline = (y + dboffset) % yres;
-		(*rgb2scr)(&dbbuffer[POINTPOS(x, dline)], COLOR(color));
-	}
-}
-
-/** Get pixel from viewport */
-static int getpixel(unsigned int x, unsigned int y)
-{
-	if (dbbuffer) {
-		int dline = (y + dboffset) % yres;
-		return COLOR((*scr2rgb)(&dbbuffer[POINTPOS(x, dline)]));
-	}
-	return COLOR((*scr2rgb)(&fbaddress[POINTPOS(x, y)]));
-}
-
-
-/** Fill screen with background color */
-static void clear_screen(void)
-{
-	unsigned int y;
-
-	for (y = 0; y < yres; y++) {
-		memcpy(&fbaddress[scanline * y], blankline, xres * pixelbytes);
-		if (dbbuffer)
-			memcpy(&dbbuffer[scanline * y], blankline,
-			    xres * pixelbytes);
-	}
-}
-
-
-/** Scroll screen one row up */
+static void rgb_323(void *dst, uint32_t rgb)
+{
+	*((uint8_t *) dst)
+	    = ~((RED(rgb, 3) << 5) | (GREEN(rgb, 2) << 3) | BLUE(rgb, 3));
+}
+
+
+/** Draw character at given position
+ *
+ */
+static void draw_glyph(uint8_t glyph, unsigned int col, unsigned int row)
+{
+	unsigned int x = COL2X(col);
+	unsigned int y = ROW2Y(row);
+	unsigned int yd;
+	
+	backbuf[BB_POS(col, row)] = glyph;
+	
+	for (yd = 0; yd < FONT_SCANLINES; yd++)
+		memcpy(&fb_addr[FB_POS(x, y + yd)],
+		    &glyphs[GLYPH_POS(glyph, yd)], glyphscanline);
+}
+
+
+/** Scroll screen down by one row
+ *
+ *
+ */
 static void scroll_screen(void)
 {
-	if (dbbuffer) {
-		count_t first;
+	unsigned int row;
+	
+	for (row = 0; row < rows; row++) {
+		unsigned int y = ROW2Y(row);
+		unsigned int yd;
 		
-		/* Clear the last row */
-		memcpy(&dbbuffer[dboffset * scanline], blankline, ROW_BYTES);
-		
-		dboffset = (dboffset + FONT_SCANLINES) % yres;
-		first = yres - dboffset;
-		
-		/* Move all rows one row up */
-		if (xres * pixelbytes == scanline) {
-			memcpy(fbaddress, &dbbuffer[dboffset * scanline],
-			    first * scanline);
-			memcpy(&fbaddress[first * scanline], dbbuffer,
-			    dboffset * scanline);
-		} else {
-			/*
-			 * When the scanline is bigger than number of bytes
-			 * in the X-resolution, chances are that the
-			 * frame buffer memory past the X-resolution is special
-			 * in some way. For example, the SUNW,ffb framebuffer
-			 * wraps this area around the beginning of the same
-			 * line. To avoid troubles, copy only memory as
-			 * specified by the resolution.
-			 */
-			unsigned int i;
-
-			for (i = 0; i < first; i++)
-				memcpy(&fbaddress[i * scanline],
-				    &dbbuffer[(dboffset + i) * scanline],
-				    xres * pixelbytes);
-			for (i = 0; i < dboffset; i++)
-				memcpy(&fbaddress[(first + i) * scanline],
-				    &dbbuffer[i * scanline], xres * pixelbytes);
+		for (yd = 0; yd < FONT_SCANLINES; yd++) {
+			unsigned int x;
+			unsigned int col;
+			
+			for (col = 0, x = 0; col < cols; col++, x += FONT_WIDTH) {
+				uint8_t glyph;
+				
+				if (row < rows - 1) {
+					if (backbuf[BB_POS(col, row)] == backbuf[BB_POS(col, row + 1)])
+						continue;
+					
+					glyph = backbuf[BB_POS(col, row + 1)];
+				} else
+					glyph = 0;
+				
+				memcpy(&fb_addr[FB_POS(x, y + yd)],
+				    &glyphs[GLYPH_POS(glyph, yd)], glyphscanline);
+			}
 		}
-	} else {
-		uint8_t *lastline = &fbaddress[(rows - 1) * ROW_BYTES];
-		
-		if (xres * pixelbytes == scanline) {
-			/* Move all rows one row up */
-			memcpy((void *) fbaddress,
-			    (void *) &fbaddress[ROW_BYTES],
-			    scanline * yres - ROW_BYTES);
-			/* Clear the last row */
-			memcpy((void *) lastline, (void *) blankline,
-			    ROW_BYTES);
-		} else {
-			/*
-			 * See the comment in the dbbuffer case.
-			 */
-			unsigned int i;
-
-			/* Move all rows one row up */
-			for (i = 0; i < yres - FONT_SCANLINES; i++)
-				memcpy(&fbaddress[i * scanline],
-				    &fbaddress[(i + FONT_SCANLINES) * scanline],
-				    xres * pixelbytes);
-			/* Clear the last row */
-			for (i = 0; i < FONT_SCANLINES; i++)
-				memcpy(&lastline[i * scanline],
-				    &blankline[i * scanline],
-				    xres * pixelbytes);
-		}
-	}
-}
-
-
-static void invert_pixel(unsigned int x, unsigned int y)
-{
-	putpixel(x, y, ~getpixel(x, y));
-}
-
-
-/** Draw one line of glyph at a given position */
-static void draw_glyph_line(unsigned int glline, unsigned int x, unsigned int y)
-{
-	unsigned int i;
-
-	for (i = 0; i < 8; i++)
-		if (glline & (1 << (7 - i))) {
-			putpixel(x + i, y, FGCOLOR);
-		} else
-			putpixel(x + i, y, BGCOLOR);
-}
-
-/***************************************************************/
-/* Character-console functions */
-
-/** Draw character at given position */
-static void draw_glyph(uint8_t glyph, unsigned int col, unsigned int row)
-{
-	unsigned int y;
-
-	for (y = 0; y < FONT_SCANLINES; y++)
-		draw_glyph_line(fb_font[glyph * FONT_SCANLINES + y],
-		    col * COL_WIDTH, row * FONT_SCANLINES + y);
-}
-
-/** Invert character at given position */
-static void invert_char(unsigned int col, unsigned int row)
-{
-	unsigned int x;
-	unsigned int y;
-
-	for (x = 0; x < COL_WIDTH; x++)
-		for (y = 0; y < FONT_SCANLINES; y++)
-			invert_pixel(col * COL_WIDTH + x,
-			    row * FONT_SCANLINES + y);
-}
-
-/** Draw character at default position */
-static void draw_char(char chr)
-{
-	draw_glyph(chr, position % columns, position / columns);
-}
-
-static void draw_logo(unsigned int startx, unsigned int starty)
-{
-	unsigned int x;
-	unsigned int y;
-	unsigned int byte;
-	unsigned int rowbytes;
-
-	rowbytes = (helenos_width - 1) / 8 + 1;
-
-	for (y = 0; y < helenos_height; y++)
-		for (x = 0; x < helenos_width; x++) {
-			byte = helenos_bits[rowbytes * y + x / 8];
-			byte >>= x % 8;
-			if (byte & 1)
-				putpixel(startx + x, starty + y,
-				    COLOR(LOGOCOLOR));
-		}
-}
-
-/***************************************************************/
-/* Stdout specific functions */
-
-static void invert_cursor(void)
-{
-	invert_char(position % columns, position / columns);
-}
+	}
+	
+	memcpy(backbuf, backbuf + cols, cols * (rows - 1));
+	memsetb(&backbuf[BB_POS(0, rows - 1)], cols, 0);
+}
+
+
+static void cursor_put(void)
+{
+	draw_glyph(CURSOR, position % cols, position / cols);
+}
+
+
+static void cursor_remove(void)
+{
+	draw_glyph(0, position % cols, position / cols);
+}
+
 
 /** Print character to screen
  *
- *  Emulate basic terminal commands
+ * Emulate basic terminal commands.
+ *
  */
 static void fb_putchar(chardev_t *dev, char ch)
@@ -402,35 +253,35 @@
 	switch (ch) {
 	case '\n':
-		invert_cursor();
-		position += columns;
-		position -= position % columns;
+		cursor_remove();
+		position += cols;
+		position -= position % cols;
 		break;
 	case '\r':
-		invert_cursor();
-		position -= position % columns;
+		cursor_remove();
+		position -= position % cols;
 		break;
 	case '\b':
-		invert_cursor();
-		if (position % columns)
+		cursor_remove();
+		if (position % cols)
 			position--;
 		break;
 	case '\t':
-		invert_cursor();
+		cursor_remove();
 		do {
-			draw_char(' ');
+			draw_glyph((uint8_t) ' ', position % cols, position / cols);
 			position++;
-		} while ((position % 8) && position < columns * rows);
+		} while ((position % 8) && (position < cols * rows));
 		break;
 	default:
-		draw_char(ch);
+		draw_glyph((uint8_t) ch, position % cols, position / cols);
 		position++;
 	}
 	
-	if (position >= columns * rows) {
-		position -= columns;
+	if (position >= cols * rows) {
+		position -= cols;
 		scroll_screen();
 	}
 	
-	invert_cursor();
+	cursor_put();
 	
 	spinlock_unlock(&fb_lock);
@@ -443,7 +294,84 @@
 
 
+/** Render glyphs
+ *
+ * Convert glyphs from device independent font
+ * description to current visual representation.
+ *
+ */
+static void render_glyphs(void)
+{
+	unsigned int glyph;
+	
+	for (glyph = 0; glyph < FONT_GLYPHS; glyph++) {
+		unsigned int y;
+		
+		for (y = 0; y < FONT_SCANLINES; y++) {
+			unsigned int x;
+			
+			for (x = 0; x < FONT_WIDTH; x++)
+				rgb_conv(&glyphs[GLYPH_POS(glyph, y) + x * pixelbytes],
+				    (fb_font[glyph * FONT_SCANLINES + y] & (1 << (7 - x))) ? FG_COLOR : BG_COLOR);
+		}
+	}
+	
+	rgb_conv(bgpixel, BG_COLOR);
+}
+
+
+/** Refresh the screen
+ *
+ */
+void fb_redraw(void)
+{
+	unsigned int row;
+	
+	for (row = 0; row < rows; row++) {
+		unsigned int y = ROW2Y(row);
+		unsigned int yd;
+		
+		for (yd = 0; yd < FONT_SCANLINES; yd++) {
+			unsigned int x;
+			unsigned int col;
+			
+			for (col = 0, x = 0; col < cols; col++, x += FONT_WIDTH)
+				memcpy(&fb_addr[FB_POS(x, y + yd)],
+			    &glyphs[GLYPH_POS(backbuf[BB_POS(col, row)], yd)],
+			    glyphscanline);
+		}
+	}
+	
+	if (COL2X(cols) < xres) {
+		unsigned int y;
+		
+		for (y = 0; y < yres; y++) {
+			unsigned int x;
+			
+			for (x = COL2X(cols); x < xres; x++)
+				memcpy(&fb_addr[FB_POS(x, y)], bgpixel, pixelbytes);
+		}
+	}
+	
+	if (ROW2Y(rows) < yres) {
+		unsigned int y;
+		
+		for (y = ROW2Y(rows); y < yres; y++) {
+			unsigned int x;
+			
+			for (x = 0; x < xres; x++)
+				memcpy(&fb_addr[FB_POS(x, y)], bgpixel, pixelbytes);
+		}
+	}
+}
+
+
 /** Initialize framebuffer as a chardev output device
  *
- * @param props  	Properties of the framebuffer device.
+ * @param addr   Physical address of the framebuffer
+ * @param x      Screen width in pixels
+ * @param y      Screen height in pixels
+ * @param scan   Bytes per one scanline
+ * @param visual Color model
+ *
  */
 void fb_init(fb_properties_t *props)
@@ -451,36 +379,29 @@
 	switch (props->visual) {
 	case VISUAL_INDIRECT_8:
-		rgb2scr = rgb_byte8;
-		scr2rgb = byte8_rgb;
+		rgb_conv = rgb_323;
 		pixelbytes = 1;
 		break;
 	case VISUAL_RGB_5_5_5:
-		rgb2scr = rgb_byte555;
-		scr2rgb = byte555_rgb;
+		rgb_conv = rgb_555;
 		pixelbytes = 2;
 		break;
 	case VISUAL_RGB_5_6_5:
-		rgb2scr = rgb_byte565;
-		scr2rgb = byte565_rgb;
+		rgb_conv = rgb_565;
 		pixelbytes = 2;
 		break;
 	case VISUAL_RGB_8_8_8:
-		rgb2scr = rgb_byte888;
-		scr2rgb = byte888_rgb;
+		rgb_conv = rgb_888;
 		pixelbytes = 3;
 		break;
 	case VISUAL_RGB_8_8_8_0:
-		rgb2scr = rgb_byte888;
-		scr2rgb = byte888_rgb;
+		rgb_conv = rgb_888;
 		pixelbytes = 4;
 		break;
 	case VISUAL_RGB_0_8_8_8:
-		rgb2scr = rgb_byte0888;
-		scr2rgb = byte0888_rgb;
+		rgb_conv = rgb_0888;
 		pixelbytes = 4;
 		break;
 	case VISUAL_BGR_0_8_8_8:
-		rgb2scr = bgr_byte0888;
-		scr2rgb = byte0888_bgr;
+		rgb_conv = bgr_0888;
 		pixelbytes = 4;
 		break;
@@ -488,11 +409,4 @@
 		panic("Unsupported visual.\n");
 	}
-	
-	unsigned int fbsize = props->scan * props->y;
-	
-	/* Map the framebuffer */
-	fbaddress = (uint8_t *) hw_map((uintptr_t) props->addr,
-		fbsize + props->offset);
-	fbaddress += props->offset;
 	
 	xres = props->x;
@@ -500,47 +414,50 @@
 	scanline = props->scan;
 	
-	rows = props->y / FONT_SCANLINES;
-	columns = props->x / COL_WIDTH;
-
+	cols = xres / FONT_WIDTH;
+	rows = yres / FONT_SCANLINES;
+	
+	glyphscanline = FONT_WIDTH * pixelbytes;
+	glyphbytes = glyphscanline * FONT_SCANLINES;
+	
+	unsigned int fbsize = scanline * yres;
+	unsigned int bbsize = cols * rows;
+	unsigned int glyphsize = FONT_GLYPHS * glyphbytes;
+	
+	backbuf = (uint8_t *) malloc(bbsize, 0);
+	if (!backbuf)
+		panic("Unable to allocate backbuffer.\n");
+	
+	glyphs = (uint8_t *) malloc(glyphsize, 0);
+	if (!glyphs)
+		panic("Unable to allocate glyphs.\n");
+	
+	bgpixel = malloc(pixelbytes, 0);
+	if (!bgpixel)
+		panic("Unable to allocate background pixel.\n");
+	
+	memsetb(backbuf, bbsize, 0);
+	memsetb(glyphs, glyphsize, 0);
+	memsetb(bgpixel, pixelbytes, 0);
+	
+	render_glyphs();
+	
+	fb_addr = (uint8_t *) hw_map((uintptr_t) props->addr, fbsize);
+	
 	fb_parea.pbase = (uintptr_t) props->addr + props->offset;
-	fb_parea.vbase = (uintptr_t) fbaddress;
+	fb_parea.vbase = (uintptr_t) fb_addr;
 	fb_parea.frames = SIZE2FRAMES(fbsize);
 	fb_parea.cacheable = false;
 	ddi_parea_register(&fb_parea);
-
+	
 	sysinfo_set_item_val("fb", NULL, true);
 	sysinfo_set_item_val("fb.kind", NULL, 1);
 	sysinfo_set_item_val("fb.width", NULL, xres);
 	sysinfo_set_item_val("fb.height", NULL, yres);
-	sysinfo_set_item_val("fb.scanline", NULL, props->scan);
+	sysinfo_set_item_val("fb.scanline", NULL, scanline);
 	sysinfo_set_item_val("fb.visual", NULL, props->visual);
 	sysinfo_set_item_val("fb.address.physical", NULL, props->addr);
-	sysinfo_set_item_val("fb.offset", NULL, props->offset);
-	sysinfo_set_item_val("fb.invert-colors", NULL, invert_colors);
-
-	/* Allocate double buffer */
-	unsigned int order = fnzb(SIZE2FRAMES(fbsize) - 1) + 1;
-	dbbuffer = (uint8_t *) frame_alloc(order, FRAME_ATOMIC | FRAME_KA);
-	if (!dbbuffer)
-		printf("Failed to allocate scroll buffer.\n");
-	dboffset = 0;
-
-	/* Initialized blank line */
-	blankline = (uint8_t *) malloc(ROW_BYTES, FRAME_ATOMIC);
-	if (!blankline)
-		panic("Failed to allocate blank line for framebuffer.");
-	unsigned int x, y;
-	for (y = 0; y < FONT_SCANLINES; y++)
-		for (x = 0; x < xres; x++)
-			(*rgb2scr)(&blankline[POINTPOS(x, y)], COLOR(BGCOLOR));
-	
-	clear_screen();
-
-	/* Update size of screen to match text area */
-	yres = rows * FONT_SCANLINES;
-
-	draw_logo(xres - helenos_width, 0);
-	invert_cursor();
-
+	
+	fb_redraw();
+	
 	chardev_initialize("fb", &framebuffer, &fb_ops);
 	stdout = &framebuffer;
Index: kernel/genarch/src/fb/font-8x16.c
===================================================================
--- kernel/genarch/src/fb/font-8x16.c	(revision 8fe5980e42d82b7d2d7e089fc06a6048def9ee08)
+++ kernel/genarch/src/fb/font-8x16.c	(revision 5ae44434cfd2872a471686a96b90a32837daa999)
@@ -35,5 +35,5 @@
 #include <genarch/fb/font-8x16.h>
 
-unsigned char fb_font[FONT_GLIPHS * FONT_SCANLINES] = {
+uint8_t fb_font[FONT_GLYPHS * FONT_SCANLINES] = {
 
 	/* 0 0x00 '^@' */
Index: kernel/genarch/src/fb/helenos.xbm
===================================================================
--- kernel/genarch/src/fb/helenos.xbm	(revision 8fe5980e42d82b7d2d7e089fc06a6048def9ee08)
+++ 	(revision )
@@ -1,163 +1,0 @@
-#define helenos_width 127
-#define helenos_height 120
-static unsigned char helenos_bits[] = {
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x1f, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x80, 0x0f, 0x78, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0xf0, 0x01, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x80, 0x81,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0,
-   0x0f, 0x00, 0x00, 0x83, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0xf0, 0x01, 0x00, 0x00, 0x03, 0x01, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x06,
-   0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x07,
-   0x00, 0x00, 0x00, 0x06, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x02, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x0c,
-   0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x03, 0x00,
-   0x00, 0x00, 0x00, 0x18, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x0c, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x80, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18,
-   0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x03, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x18, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x80, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60,
-   0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x01, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x60, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x20, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0xc0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0,
-   0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0xc0, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x80, 0xc1, 0x00, 0x00, 0x00,
-   0x00, 0xc0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x80,
-   0xc1, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0xfe, 0x01, 0x00, 0x00, 0x83, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0xff, 0x03, 0x00, 0x00, 0x83, 0x01, 0x00, 0x00,
-   0x00, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x03, 0x00, 0x00,
-   0x03, 0x01, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0xff, 0x07, 0x00, 0x00, 0x06, 0x03, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0xff, 0x07, 0x00, 0x00, 0x06, 0x03, 0x00, 0x00,
-   0x08, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x07, 0x00, 0x00,
-   0x0c, 0x02, 0x00, 0x00, 0x08, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0xff, 0x0f, 0x00, 0x00, 0x0c, 0x06, 0x00, 0x00, 0x08, 0x03, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0xfe, 0x0f, 0x00, 0x00, 0x18, 0x04, 0x00, 0x00,
-   0x08, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x1f, 0x00, 0x00,
-   0x18, 0x0c, 0x00, 0x00, 0x08, 0x03, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00,
-   0xfc, 0x1f, 0x00, 0x00, 0x18, 0x0c, 0x00, 0x00, 0x08, 0x03, 0x00, 0x00,
-   0x80, 0x1f, 0x00, 0x00, 0xfc, 0x1f, 0x00, 0x00, 0x30, 0x18, 0x00, 0x00,
-   0x18, 0x02, 0x00, 0x00, 0xc0, 0x3f, 0x00, 0x00, 0xfc, 0x3f, 0x00, 0x00,
-   0x30, 0x18, 0x00, 0x00, 0x18, 0x06, 0x00, 0x00, 0xe0, 0x7f, 0x00, 0x00,
-   0xf8, 0x3f, 0x00, 0x00, 0x60, 0x10, 0x00, 0x00, 0x18, 0x06, 0x00, 0x00,
-   0xe0, 0x7f, 0x00, 0x00, 0xf8, 0x7f, 0x00, 0x00, 0x60, 0x30, 0x00, 0x00,
-   0x38, 0x0c, 0x00, 0x00, 0xf0, 0x7f, 0x00, 0x00, 0xf0, 0x7f, 0x00, 0x00,
-   0xe0, 0x20, 0x00, 0x00, 0x30, 0x0c, 0x00, 0x00, 0xe0, 0xff, 0x00, 0x00,
-   0xf0, 0x7f, 0x00, 0x00, 0xc0, 0x78, 0x00, 0x00, 0x70, 0x08, 0x00, 0x00,
-   0xe0, 0xff, 0x00, 0x00, 0xf0, 0xff, 0x00, 0x00, 0xc0, 0x7c, 0x00, 0x00,
-   0x70, 0x18, 0x00, 0x00, 0xe0, 0xff, 0x01, 0x00, 0xf0, 0xff, 0x00, 0x00,
-   0x80, 0xfd, 0x00, 0x00, 0x60, 0x3f, 0x00, 0x00, 0xc0, 0xff, 0x01, 0x00,
-   0xfc, 0xff, 0x01, 0x00, 0x80, 0xf9, 0x00, 0x00, 0xe0, 0x3f, 0x00, 0x00,
-   0xc0, 0xff, 0x01, 0x80, 0xff, 0xff, 0x01, 0x00, 0x80, 0xfb, 0x00, 0x00,
-   0xc0, 0x7f, 0x00, 0x00, 0xc0, 0xff, 0x03, 0xe0, 0xff, 0xff, 0x03, 0x00,
-   0x00, 0xf3, 0x01, 0x00, 0xc0, 0x7f, 0x00, 0x00, 0x80, 0xff, 0x03, 0xfc,
-   0xff, 0xff, 0x03, 0x00, 0x00, 0xf3, 0x01, 0x00, 0xc0, 0x7f, 0x00, 0x00,
-   0x80, 0xff, 0x07, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0xf6, 0x03, 0x00,
-   0x80, 0xff, 0x00, 0x00, 0x00, 0xff, 0xe7, 0xff, 0xff, 0xff, 0x07, 0x00,
-   0x00, 0xe6, 0x03, 0x00, 0x80, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
-   0xff, 0xff, 0x07, 0x00, 0x00, 0xec, 0x07, 0x00, 0x00, 0xff, 0x01, 0x00,
-   0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00, 0x00, 0xcc, 0x07, 0x00,
-   0x00, 0xff, 0x01, 0x00, 0x00, 0xfe, 0xff, 0xff, 0x7f, 0xfe, 0x0f, 0x00,
-   0x00, 0xdc, 0x07, 0x00, 0x00, 0xff, 0x01, 0x00, 0x00, 0xfe, 0xff, 0xff,
-   0x1f, 0xfe, 0x0f, 0x00, 0x00, 0xd8, 0x0f, 0x00, 0x00, 0xfe, 0x03, 0x00,
-   0x00, 0xfc, 0xff, 0xff, 0x03, 0xfe, 0x1f, 0x00, 0x00, 0x98, 0x0f, 0x00,
-   0x00, 0xfe, 0x03, 0x00, 0x00, 0xfc, 0xff, 0xff, 0x00, 0xfc, 0x1f, 0x00,
-   0x00, 0xb0, 0x1f, 0x00, 0x00, 0xfc, 0x07, 0x00, 0x00, 0xf8, 0xff, 0x1f,
-   0x00, 0xfc, 0x3f, 0x00, 0x00, 0x30, 0x1f, 0x00, 0x00, 0xfc, 0x07, 0x00,
-   0x00, 0xf8, 0xff, 0x07, 0x00, 0xfc, 0x3f, 0x00, 0x00, 0x70, 0x1f, 0x00,
-   0x00, 0xfc, 0x07, 0x00, 0x00, 0xf8, 0xff, 0x00, 0x00, 0xf8, 0x7f, 0x00,
-   0x00, 0x60, 0x3e, 0x00, 0x00, 0xf8, 0x0f, 0x00, 0x00, 0xf0, 0x7f, 0x00,
-   0x00, 0xf8, 0x7f, 0x00, 0x00, 0xe0, 0x3e, 0x00, 0x00, 0xf8, 0x0f, 0x00,
-   0x00, 0xf0, 0x7f, 0x00, 0x00, 0xf0, 0x7f, 0x00, 0x00, 0xf8, 0x7e, 0x00,
-   0x00, 0xf0, 0x1f, 0x00, 0x00, 0xf0, 0xff, 0x00, 0x00, 0xf0, 0xff, 0x00,
-   0x00, 0xfc, 0x7c, 0x00, 0x00, 0xf0, 0x1f, 0x00, 0x00, 0xe0, 0xff, 0x00,
-   0x00, 0xf0, 0xff, 0x00, 0x00, 0xfe, 0xfd, 0x00, 0x00, 0xf0, 0x1f, 0x00,
-   0x00, 0xe0, 0xff, 0x01, 0x00, 0xe0, 0xff, 0x00, 0x80, 0xff, 0xf9, 0x00,
-   0x00, 0xe0, 0x3f, 0x00, 0x00, 0xc0, 0xff, 0x01, 0x00, 0xe0, 0xff, 0x00,
-   0xc0, 0xff, 0xfb, 0x00, 0x00, 0xe0, 0x3f, 0x00, 0x00, 0xc0, 0xff, 0x03,
-   0x00, 0xc0, 0x7f, 0x00, 0xe0, 0xff, 0xfb, 0x01, 0x00, 0xc0, 0x7f, 0x00,
-   0x00, 0x80, 0xff, 0x03, 0x00, 0xc0, 0x7f, 0x00, 0xf8, 0xff, 0xf7, 0x01,
-   0x00, 0xc0, 0x7f, 0x00, 0x00, 0x80, 0xff, 0x03, 0x00, 0x80, 0x3f, 0x00,
-   0xfc, 0xff, 0xf7, 0x03, 0x00, 0xc0, 0x7f, 0x00, 0x00, 0x80, 0xff, 0x07,
-   0x00, 0x00, 0x00, 0x00, 0xfe, 0xef, 0xe7, 0x03, 0x00, 0x80, 0xff, 0x00,
-   0x00, 0x00, 0xff, 0x07, 0x00, 0x00, 0x00, 0x80, 0xff, 0xdf, 0xef, 0x07,
-   0x00, 0x80, 0xff, 0x00, 0x00, 0x00, 0xff, 0x0f, 0x00, 0x00, 0x00, 0xc0,
-   0xff, 0xdf, 0xef, 0x07, 0x00, 0x00, 0xff, 0x01, 0x00, 0x00, 0xff, 0x0f,
-   0x00, 0x00, 0x00, 0xe0, 0xff, 0xcf, 0xcf, 0x07, 0x00, 0x00, 0xff, 0x01,
-   0x00, 0x00, 0xfe, 0x1f, 0x00, 0x00, 0x00, 0xf0, 0x7f, 0xc3, 0xcf, 0x0f,
-   0x00, 0x00, 0xff, 0x01, 0x00, 0x00, 0xfe, 0x1f, 0x00, 0x00, 0x00, 0xfc,
-   0xff, 0xe0, 0xcf, 0x0f, 0x00, 0x00, 0xfe, 0x03, 0x00, 0x00, 0xfc, 0x1f,
-   0x00, 0x00, 0x00, 0xfe, 0xff, 0xf9, 0xc7, 0x0f, 0x00, 0x00, 0xfe, 0x03,
-   0x00, 0x00, 0xfc, 0x1f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xe7, 0x0f,
-   0x00, 0x00, 0xfc, 0x07, 0x00, 0x00, 0xf8, 0x0f, 0x00, 0x00, 0xc0, 0xff,
-   0xff, 0xff, 0xe7, 0x0f, 0x00, 0x00, 0xfc, 0x07, 0x00, 0x00, 0xf8, 0x07,
-   0x00, 0x00, 0xe0, 0xff, 0xff, 0xff, 0xe3, 0x0f, 0x00, 0x00, 0xfc, 0x0f,
-   0x00, 0x00, 0xf0, 0x03, 0x00, 0x00, 0xf0, 0xff, 0xff, 0xff, 0xf1, 0x0f,
-   0x00, 0x00, 0xf8, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff,
-   0xff, 0xff, 0xf8, 0x0f, 0x00, 0x00, 0xf8, 0x0f, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0xfe, 0xff, 0xff, 0x3f, 0xfc, 0x0f, 0x00, 0x00, 0xf0, 0x1f,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x07, 0xfe, 0x0f,
-   0x00, 0x00, 0xf0, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff,
-   0xff, 0x81, 0xff, 0x07, 0x00, 0x00, 0xf0, 0x3f, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0xe0, 0xff, 0xff, 0x3f, 0xe0, 0xff, 0x07, 0x00, 0x00, 0xe0, 0x3f,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff, 0xff, 0x07, 0xfc, 0xff, 0x07,
-   0x00, 0x00, 0xe0, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff,
-   0x80, 0xff, 0xff, 0x03, 0x00, 0x00, 0xc0, 0x7f, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0xfe, 0xff, 0x1f, 0xf0, 0xff, 0xff, 0x01, 0x00, 0x00, 0xc0, 0x7f,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x07, 0xfe, 0xff, 0xff, 0x00,
-   0x00, 0x00, 0xc0, 0x3f, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0xc0,
-   0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x80, 0xbf, 0x00, 0x00, 0x00, 0x00,
-   0xe0, 0xff, 0x1f, 0xf0, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x80, 0xdf,
-   0x00, 0x3c, 0x00, 0x00, 0xf0, 0xff, 0x03, 0xfe, 0xff, 0xff, 0x0f, 0x00,
-   0x00, 0x00, 0x00, 0xcf, 0x00, 0x7e, 0x00, 0x00, 0xfc, 0x7f, 0xc0, 0xff,
-   0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x8f, 0x01, 0x7e, 0x00, 0x00,
-   0xfe, 0x0f, 0xf8, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x97,
-   0x01, 0x3e, 0x00, 0x00, 0xff, 0x03, 0xff, 0xff, 0xff, 0x0f, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x9e, 0x03, 0x00, 0x00, 0xc0, 0x7f, 0xc0, 0xff, 0xff,
-   0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x03, 0x00, 0x00, 0xe0,
-   0x0f, 0xf8, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c,
-   0x03, 0x00, 0x00, 0xf8, 0x01, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x7c, 0x06, 0x00, 0x00, 0x3f, 0xe0, 0xff, 0xff, 0xff,
-   0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0x0e, 0x00, 0xe0, 0x0f,
-   0xfc, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8,
-   0x3c, 0x00, 0xfc, 0x01, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0xf8, 0x78, 0x80, 0x3f, 0xe0, 0xff, 0xff, 0xff, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xe1, 0xff, 0x07, 0xfc,
-   0xff, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0,
-   0x81, 0xff, 0x80, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0xf0, 0x03, 0x00, 0xf0, 0xff, 0xff, 0xff, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x07, 0x00, 0xfe, 0xff,
-   0xff, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0,
-   0x0f, 0x00, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0xc0, 0x3f, 0xc0, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0xff, 0xff,
-   0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0,
-   0xff, 0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x1f,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0xff, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0x0f, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0xf0, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
Index: kernel/genarch/src/mm/asid.c
===================================================================
--- kernel/genarch/src/mm/asid.c	(revision 8fe5980e42d82b7d2d7e089fc06a6048def9ee08)
+++ kernel/genarch/src/mm/asid.c	(revision 5ae44434cfd2872a471686a96b90a32837daa999)
@@ -33,5 +33,5 @@
 /**
  * @file
- * @brief	ASID management.
+ * @brief ASID management.
  *
  * Modern processor architectures optimize TLB utilization
Index: kernel/generic/include/console/kconsole.h
===================================================================
--- kernel/generic/include/console/kconsole.h	(revision 8fe5980e42d82b7d2d7e089fc06a6048def9ee08)
+++ kernel/generic/include/console/kconsole.h	(revision 5ae44434cfd2872a471686a96b90a32837daa999)
@@ -88,5 +88,6 @@
 
 extern void kconsole_init(void);
-extern void kconsole(void *prompt);
+extern void kconsole(char *prompt, char *msg, bool kcon);
+extern void kconsole_thread(void *data);
 
 extern int cmd_register(cmd_info_t *cmd);
Index: kernel/generic/src/console/cmd.c
===================================================================
--- kernel/generic/src/console/cmd.c	(revision 8fe5980e42d82b7d2d7e089fc06a6048def9ee08)
+++ kernel/generic/src/console/cmd.c	(revision 5ae44434cfd2872a471686a96b90a32837daa999)
@@ -502,5 +502,5 @@
 		cmd_initialize(basic_commands[i]);
 		if (!cmd_register(basic_commands[i]))
-			panic("could not register command %s\n", basic_commands[i]->name);
+			printf("Cannot register command %s\n", basic_commands[i]->name);
 	}
 }
Index: kernel/generic/src/console/console.c
===================================================================
--- kernel/generic/src/console/console.c	(revision 8fe5980e42d82b7d2d7e089fc06a6048def9ee08)
+++ kernel/generic/src/console/console.c	(revision 5ae44434cfd2872a471686a96b90a32837daa999)
@@ -168,5 +168,5 @@
 		else
 			printf("cpu: ");
-		printf("halted - no kconsole\n");
+		printf("halted (no kconsole)\n");
 		cpu_halt();
 	}
Index: kernel/generic/src/console/kconsole.c
===================================================================
--- kernel/generic/src/console/kconsole.c	(revision 8fe5980e42d82b7d2d7e089fc06a6048def9ee08)
+++ kernel/generic/src/console/kconsole.c	(revision 5ae44434cfd2872a471686a96b90a32837daa999)
@@ -402,9 +402,13 @@
 }
 
-/** Kernel console managing thread.
+/** Kernel console prompt.
  *
  * @param prompt Kernel console prompt (e.g kconsole/panic).
- */
-void kconsole(void *prompt)
+ * @param msg    Message to display in the beginning.
+ * @param kcon   Wait for keypress to show the prompt
+ *               and never exit.
+ *
+ */
+void kconsole(char *prompt, char *msg, bool kcon)
 {
 	cmd_info_t *cmd_info;
@@ -413,7 +417,13 @@
 
 	if (!stdin) {
-		printf("%s: no stdin\n", __func__);
+		LOG("No stdin for kernel console");
 		return;
 	}
+	
+	if (msg)
+		printf("%s", msg);
+	
+	if (kcon)
+		_getc(stdin);
 	
 	while (true) {
@@ -422,12 +432,23 @@
 		if (!len)
 			continue;
+		
 		cmd_info = parse_cmdline(cmdline, len);
 		if (!cmd_info)
 			continue;
-		if (strncmp(cmd_info->name, "exit",
-		    min(strlen(cmd_info->name), 5)) == 0)
+		
+		if ((!kcon)
+		    && (strncmp(cmd_info->name, "exit", min(strlen(cmd_info->name), 5)) == 0))
 			break;
+		
 		(void) cmd_info->func(cmd_info->argv);
 	}
+}
+
+/** Kernel console managing thread.
+ *
+ */
+void kconsole_thread(void *data)
+{
+	kconsole("kconsole", "Kernel console ready (press any key to activate)\n", true);
 }
 
Index: kernel/generic/src/cpu/cpu.c
===================================================================
--- kernel/generic/src/cpu/cpu.c	(revision 8fe5980e42d82b7d2d7e089fc06a6048def9ee08)
+++ kernel/generic/src/cpu/cpu.c	(revision 5ae44434cfd2872a471686a96b90a32837daa999)
@@ -87,5 +87,5 @@
 #endif /* CONFIG_SMP */
 
-	CPU = &cpus[config.cpu_active-1];
+	CPU = &cpus[config.cpu_active - 1];
 	
 	CPU->active = 1;
Index: kernel/generic/src/interrupt/interrupt.c
===================================================================
--- kernel/generic/src/interrupt/interrupt.c	(revision 8fe5980e42d82b7d2d7e089fc06a6048def9ee08)
+++ kernel/generic/src/interrupt/interrupt.c	(revision 5ae44434cfd2872a471686a96b90a32837daa999)
@@ -110,6 +110,8 @@
 }
 
+#ifdef CONFIG_KCONSOLE
+
 /** kconsole cmd - print all exceptions */
-static int exc_print_cmd(cmd_arg_t *argv)
+static int cmd_exc_print(cmd_arg_t *argv)
 {
 #if (IVT_ITEMS > 0)
@@ -159,12 +161,15 @@
 }
 
+
 static cmd_info_t exc_info = {
 	.name = "exc",
 	.description = "Print exception table.",
-	.func = exc_print_cmd,
+	.func = cmd_exc_print,
 	.help = NULL,
 	.argc = 0,
 	.argv = NULL
 };
+
+#endif
 
 /** Initialize generic exception handling support */
@@ -176,7 +181,9 @@
 		exc_register(i, "undef", (iroutine) exc_undef);
 
+#ifdef CONFIG_KCONSOLE
 	cmd_initialize(&exc_info);
 	if (!cmd_register(&exc_info))
-		panic("could not register command %s\n", exc_info.name);
+		printf("Cannot register command %s\n", exc_info.name);
+#endif
 }
 
Index: kernel/generic/src/lib/func.c
===================================================================
--- kernel/generic/src/lib/func.c	(revision 8fe5980e42d82b7d2d7e089fc06a6048def9ee08)
+++ kernel/generic/src/lib/func.c	(revision 5ae44434cfd2872a471686a96b90a32837daa999)
@@ -56,6 +56,4 @@
 	bool rundebugger = false;
 
-//      TODO test_and_set not defined on all arches
-//	if (!test_and_set(&haltstate))
 	if (!atomic_get(&haltstate)) {
 		atomic_set(&haltstate, 1);
@@ -67,10 +65,10 @@
 
 	interrupts_disable();
-#ifdef CONFIG_DEBUG
-	if (rundebugger) {
-		printf("\n");
-		kconsole("panic"); /* Run kconsole as a last resort to user */
-	}
-#endif      
+	
+#if (defined(CONFIG_DEBUG)) && (defined(CONFIG_KCONSOLE))
+	if (rundebugger)
+		kconsole("panic", "\nLast resort kernel console ready\n", false);
+#endif
+	
 	if (CPU)
 		printf("cpu%u: halted\n", CPU->id);
Index: kernel/generic/src/main/kinit.c
===================================================================
--- kernel/generic/src/main/kinit.c	(revision 8fe5980e42d82b7d2d7e089fc06a6048def9ee08)
+++ kernel/generic/src/main/kinit.c	(revision 5ae44434cfd2872a471686a96b90a32837daa999)
@@ -83,5 +83,8 @@
 void kinit(void *arg)
 {
-	thread_t *t;
+
+#if defined(CONFIG_SMP) || defined(CONFIG_KCONSOLE)
+	thread_t *thread;
+#endif
 
 	/*
@@ -101,21 +104,17 @@
 		 * Just a beautification.
 		 */
-		if ((t = thread_create(kmp, NULL, TASK, THREAD_FLAG_WIRED,
-		    "kmp", true))) {
-			spinlock_lock(&t->lock);
-			t->cpu = &cpus[0];
-			spinlock_unlock(&t->lock);
-			thread_ready(t);
+		thread = thread_create(kmp, NULL, TASK, THREAD_FLAG_WIRED, "kmp", true);
+		if (thread != NULL) {
+			spinlock_lock(&thread->lock);
+			thread->cpu = &cpus[0];
+			spinlock_unlock(&thread->lock);
+			thread_ready(thread);
 		} else
-			panic("thread_create/kmp\n");
-		thread_join(t);
-		thread_detach(t);
+			panic("Unable to create kmp thread\n");
+		thread_join(thread);
+		thread_detach(thread);
 	}
 #endif /* CONFIG_SMP */
-	/*
-	 * Now that all CPUs are up, we can report what we've found.
-	 */
-	cpu_list();
-
+	
 #ifdef CONFIG_SMP
 	if (config.cpu_count > 1) {
@@ -126,18 +125,17 @@
 		 */
 		for (i = 0; i < config.cpu_count; i++) {
-
-			if ((t = thread_create(kcpulb, NULL, TASK,
-			    THREAD_FLAG_WIRED, "kcpulb", true))) {
-				spinlock_lock(&t->lock);			
-				t->cpu = &cpus[i];
-				spinlock_unlock(&t->lock);
-				thread_ready(t);
+			thread = thread_create(kcpulb, NULL, TASK, THREAD_FLAG_WIRED, "kcpulb", true);
+			if (thread != NULL) {
+				spinlock_lock(&thread->lock);
+				thread->cpu = &cpus[i];
+				spinlock_unlock(&thread->lock);
+				thread_ready(thread);
 			} else
-				panic("thread_create/kcpulb\n");
+				printf("Unable to create kcpulb thread for cpu" PRIc "\n", i);
 
 		}
 	}
 #endif /* CONFIG_SMP */
-
+	
 	/*
 	 * At this point SMP, if present, is configured.
@@ -145,14 +143,17 @@
 	arch_post_smp_init();
 
-	/*
-	 * Create kernel console.
-	 */
-	t = thread_create(kconsole, (void *) "kconsole", TASK, 0, "kconsole",
-	    false);
-	if (t)
-		thread_ready(t);
-	else
-		panic("thread_create/kconsole\n");
-
+#ifdef CONFIG_KCONSOLE
+	if (stdin) {
+		/*
+		 * Create kernel console.
+		 */
+		thread = thread_create(kconsole_thread, NULL, TASK, 0, "kconsole", false);
+		if (thread != NULL)
+			thread_ready(thread);
+		else
+			printf("Unable to create kconsole thread\n");
+	}
+#endif /* CONFIG_KCONSOLE */
+	
 	interrupts_enable();
 	
@@ -165,12 +166,12 @@
 	for (i = 0; i < init.cnt; i++) {
 		if (init.tasks[i].addr % FRAME_SIZE) {
-			printf("init[%" PRIc "].addr is not frame aligned", i);
+			printf("init[%" PRIc "].addr is not frame aligned\n", i);
 			continue;
 		}
-
+		
 		int rc = program_create_from_image((void *) init.tasks[i].addr,
 		    "init-bin", &programs[i]);
-
-		if (rc == 0 && programs[i].task != NULL) {
+		
+		if ((rc == 0) && (programs[i].task != NULL)) {
 			/*
 			 * Set capabilities to init userspace tasks.
@@ -185,10 +186,8 @@
 		} else {
 			/* RAM disk image */
-			int rd = init_rd((rd_header_t *) init.tasks[i].addr,
-			    init.tasks[i].size);
+			int rd = init_rd((rd_header_t *) init.tasks[i].addr, init.tasks[i].size);
 			
 			if (rd != RE_OK)
-				printf("Init binary %" PRIc " not used, error "
-				    "code %d.\n", i, rd);
+				printf("Init binary %" PRIc " not used (error %d)\n", i, rd);
 		}
 	}
@@ -204,10 +203,16 @@
 	}
 
+#ifdef CONFIG_KCONSOLE
 	if (!stdin) {
+		printf("kinit: No stdin\nKernel alive: ");
+		
+		uint64_t i = 0;
 		while (1) {
+			printf(PRIu64 " ", i);
 			thread_sleep(1);
-			printf("kinit... ");
-		}
-	}
+			i++;
+		}
+	}
+#endif /* CONFIG_KCONSOLE */
 }
 
Index: kernel/generic/src/main/main.c
===================================================================
--- kernel/generic/src/main/main.c	(revision 8fe5980e42d82b7d2d7e089fc06a6048def9ee08)
+++ kernel/generic/src/main/main.c	(revision 5ae44434cfd2872a471686a96b90a32837daa999)
@@ -192,6 +192,4 @@
 	/* Keep this the first thing. */
 	the_initialize(THE);
-
-	LOG();
 	
 	version_print();
@@ -201,6 +199,6 @@
 	    config.base, config.kernel_size, config.stack_base,
 	    config.stack_size);
-	
-
+
+#ifdef CONFIG_KCONSOLE
 	/*
 	 * kconsole data structures must be initialized very early
@@ -209,4 +207,5 @@
 	 */
 	LOG_EXEC(kconsole_init());
+#endif
 	
 	/*
@@ -253,5 +252,5 @@
 		count_t i;
 		for (i = 0; i < init.cnt; i++)
-			printf("init[%" PRIc "].addr=%#" PRIp ", init[%" PRIc
+			LOG("init[%" PRIc "].addr=%#" PRIp ", init[%" PRIc
 			    "].size=%#" PRIs "\n", i, init.tasks[i].addr, i,
 			    init.tasks[i].size);
@@ -272,6 +271,6 @@
 	 * Create the first thread.
 	 */
-	thread_t *kinit_thread = thread_create(kinit, NULL, kernel, 0, "kinit",
-	    true);
+	thread_t *kinit_thread
+		= thread_create(kinit, NULL, kernel, 0, "kinit", true);
 	if (!kinit_thread)
 		panic("Can't create kinit thread\n");
Index: kernel/generic/src/mm/as.c
===================================================================
--- kernel/generic/src/mm/as.c	(revision 8fe5980e42d82b7d2d7e089fc06a6048def9ee08)
+++ kernel/generic/src/mm/as.c	(revision 5ae44434cfd2872a471686a96b90a32837daa999)
@@ -147,6 +147,10 @@
 	AS_KERNEL = as_create(FLAG_AS_KERNEL);
 	if (!AS_KERNEL)
-		panic("can't create kernel address space\n");
-	
+		panic("Cannot create kernel address space\n");
+	
+	/* Make sure the kernel address space
+	 * reference count never drops to zero.
+	 */
+	atomic_set(&AS_KERNEL->refcount, 1);
 }
 
@@ -177,5 +181,5 @@
 	page_table_create(flags);
 #endif
-
+	
 	return as;
 }
@@ -770,9 +774,10 @@
  * into private anonymous memory (unless it's already there).
  *
- * @param as		Address space.
- * @param flags		Flags of the area memory.
- * @param address	Address withing the area to be changed.
- *
- * @return		Zero on success or a value from @ref errno.h on failure.
+ * @param as      Address space.
+ * @param flags   Flags of the area memory.
+ * @param address Address within the area to be changed.
+ *
+ * @return Zero on success or a value from @ref errno.h on failure.
+ *
  */
 int as_area_change_flags(as_t *as, int flags, uintptr_t address)
@@ -786,5 +791,5 @@
 	index_t frame_idx;
 	count_t used_pages;
-
+	
 	/* Flags for the new memory mapping */
 	page_flags = area_flags_to_page_flags(flags);
@@ -800,5 +805,5 @@
 	}
 
-	if (area->sh_info || area->backend != &anon_backend) {
+	if ((area->sh_info) || (area->backend != &anon_backend)) {
 		/* Copying shared areas not supported yet */
 		/* Copying non-anonymous memory not supported yet */
@@ -871,4 +876,5 @@
 
 	tlb_invalidate_pages(as->asid, area->base, area->pages);
+	
 	/*
 	 * Invalidate potential software translation caches (e.g. TSB on
Index: kernel/generic/src/syscall/syscall.c
===================================================================
--- kernel/generic/src/syscall/syscall.c	(revision 8fe5980e42d82b7d2d7e089fc06a6048def9ee08)
+++ kernel/generic/src/syscall/syscall.c	(revision 5ae44434cfd2872a471686a96b90a32837daa999)
@@ -93,6 +93,10 @@
 static unative_t sys_debug_enable_console(void)
 {
+#ifdef CONFIG_KCONSOLE
 	arch_grab_console();
-	return 0;
+	return true;
+#else
+	return false;
+#endif
 }