WebSVN – HelenOS – Path Comparison – / – /branches/dynload/ Rev 4342 and /branches/dynload/ Rev 4343

Ignore whitespace Rev 4342 → Rev 4343

 /branches/dynload/contrib/conf/msim.conf
 ,6 → 3,7
 #
 add dcpu cpu0
+add dcpu cpu1
 add rwm mainmem 0x00000000
 mainmem generic 16M
 ,7 → 11,7
 add rom bootmem 0x1fc00000
 bootmem generic 4096k
-bootmem load "image.boot"
+bootmem load "image.boot"
 add dprinter printer 0x10000000
 add dkeyboard keyboard 0x10000000 2

 /branches/dynload/kernel/test/debug/mips1_skip.c
 ,0 → 1,34
+/*
+ * Copyright (c) 2009 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <test.h>
+char *test_mips1(bool quiet)
+{
+    return NULL;
+}

 /branches/dynload/kernel/test/debug/mips1.def
 ,4 → 1,3
-#ifdef mips32
 {
     "mips1",
     "MIPS debug test",
 ,4 → 4,3
     &test_mips1,
     false
 },
-#endif

 /branches/dynload/kernel/test/debug/mips1.c
 ,8 → 25,6
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-#ifdef mips32
 #include <print.h>
 #include <debug.h>
 ,5 → 47,3
     return "Back from debug mode";
 }
-#endif

 /branches/dynload/kernel/test/mm/purge1.def
 ,4 → 1,3
-#ifdef ia64
 {
     "purge1",
     "Itanium TLB purge test",
 ,4 → 4,3
     &test_purge1,
     true
 },
-#endif

 /branches/dynload/kernel/test/mm/purge1.c
 ,8 → 26,6
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-#ifdef ia64
 #include <print.h>
 #include <test.h>
 #include <mm/page.h>
 ,10 → 45,10
     tlb_entry_t entryd;
     int i;
     entryd.word[0] = 0;
     entryd.word[1] = 0;
     entryd.p = true;                 /* present */
     entryd.ma = MA_WRITEBACK;
     entryd.a = true;                 /* already accessed */
 ,11 → 75,9
         dtc_mapping_insert(0 + i * (1 << PAGE_WIDTH), 9, entryd);
     }
-    tlb_invalidate_pages(8,0x0c000,14);
+    tlb_invalidate_pages(8, 0x0c000, 14);
-    /*tlb_invalidate_all();*/
+    /* tlb_invalidate_all(); */
     return NULL;
 }
-#endif

 /branches/dynload/kernel/test/mm/purge1_skip.c
 ,0 → 1,34
+/*
+ * Copyright (c) 2009 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <test.h>
+char *test_purge1(bool quiet)
+{
+    return NULL;
+}

 /branches/dynload/kernel/test/fpu/fpu1_ia64.c
 ,0 → 1,179
+/*
+ * Copyright (c) 2005 Jakub Vana
+ * Copyright (c) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <print.h>
+#include <debug.h>
+#include <test.h>
+#include <atomic.h>
+#include <proc/thread.h>
+#include <arch.h>
+#include <arch/arch.h>
+#define THREADS   150
+#define ATTEMPTS  100
+#define E_10e8   271828182
+#define PI_10e8  3141592
+static inline long double sqrt(long double a)
+{
+    long double x = 1;
+    long double lx = 0;
+    if (a < 0.00000000000000001)
+        return 0;
+    while (x != lx) {
+        lx = x;
+        x = (x + (a / x)) / 2;
+    }
+    return x;
+}
+static atomic_t threads_ok;
+static atomic_t threads_fault;
+static waitq_t can_start;
+static bool sh_quiet;
+static void e(void *data)
+{
+    int i;
+    double e, d, le, f;
+    thread_detach(THREAD);
+    waitq_sleep(&can_start);
+    for (i = 0; i<ATTEMPTS; i++) {
+        le = -1;
+        e = 0;
+        f = 1;
+        for (d = 1; e != le; d *= f, f += 1) {
+            le = e;
+            e = e + 1 / d;
+        }
+        if ((int) (100000000 * e) != E_10e8) {
+            if (!sh_quiet)
+                printf("tid%" PRIu64 ": e*10e8=%zd should be %" PRIun "\n", THREAD->tid, (unative_t) (100000000 * e), (unative_t) E_10e8);
+            atomic_inc(&threads_fault);
+            break;
+        }
+    }
+    atomic_inc(&threads_ok);
+}
+static void pi(void *data)
+{
+    int i;
+    double lpi, pi;
+    double n, ab, ad;
+    thread_detach(THREAD);
+    waitq_sleep(&can_start);
+    for (i = 0; i < ATTEMPTS; i++) {
+        lpi = -1;
+        pi = 0;
+        for (n = 2, ab = sqrt(2); lpi != pi; n *= 2, ab = ad) {
+            double sc, cd;
+            sc = sqrt(1 - (ab * ab / 4));
+            cd = 1 - sc;
+            ad = sqrt(ab * ab / 4 + cd * cd);
+            lpi = pi;
+            pi = 2 * n * ad;
+        }
+        if ((int) (1000000 * pi) != PI_10e8) {
+            if (!sh_quiet)
+                printf("tid%" PRIu64 ": pi*10e8=%zd should be %" PRIun "\n", THREAD->tid, (unative_t) (1000000 * pi), (unative_t) (PI_10e8 / 100));
+            atomic_inc(&threads_fault);
+            break;
+        }
+    }
+    atomic_inc(&threads_ok);
+}
+char * test_fpu1(bool quiet)
+{
+    unsigned int i, total = 0;
+    sh_quiet = quiet;
+    waitq_initialize(&can_start);
+    atomic_set(&threads_ok, 0);
+    atomic_set(&threads_fault, 0);
+    if (!quiet)
+        printf("Creating %u threads... ", 2 * THREADS);
+    for (i = 0; i < THREADS; i++) {
+        thread_t *t;
+        if (!(t = thread_create(e, NULL, TASK, 0, "e", false))) {
+            if (!quiet)
+                printf("could not create thread %u\n", 2 * i);
+            break;
+        }
+        thread_ready(t);
+        total++;
+        if (!(t = thread_create(pi, NULL, TASK, 0, "pi", false))) {
+            if (!quiet)
+                printf("could not create thread %u\n", 2 * i + 1);
+            break;
+        }
+        thread_ready(t);
+        total++;
+    }
+    if (!quiet)
+        printf("ok\n");
+    thread_sleep(1);
+    waitq_wakeup(&can_start, WAKEUP_ALL);
+    while (atomic_get(&threads_ok) != (long) total) {
+        if (!quiet)
+            printf("Threads left: %d\n", total - atomic_get(&threads_ok));
+        thread_sleep(1);
+    }
+    if (atomic_get(&threads_fault) == 0)
+        return NULL;
+    return "Test failed";
+}

 /branches/dynload/kernel/test/fpu/fpu1_x86.c
 ,0 → 1,176
+/*
+ * Copyright (c) 2005 Jakub Vana
+ * Copyright (c) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <print.h>
+#include <debug.h>
+#include <test.h>
+#include <atomic.h>
+#include <proc/thread.h>
+#include <arch.h>
+#include <arch/arch.h>
+#define THREADS   150
+#define ATTEMPTS  100
+#define E_10e8   271828182
+#define PI_10e8  314159265
+static inline double sqrt(double x)
+{
+    double v;
+    asm (
+        "fsqrt\n"
+        : "=t" (v)
+        : "0" (x)
+    );
+    return v;
+}
+static atomic_t threads_ok;
+static atomic_t threads_fault;
+static waitq_t can_start;
+static bool sh_quiet;
+static void e(void *data)
+{
+    int i;
+    double e, d, le, f;
+    thread_detach(THREAD);
+    waitq_sleep(&can_start);
+    for (i = 0; i<ATTEMPTS; i++) {
+        le = -1;
+        e = 0;
+        f = 1;
+        for (d = 1; e != le; d *= f, f += 1) {
+            le = e;
+            e = e + 1 / d;
+        }
+        if ((int) (100000000 * e) != E_10e8) {
+            if (!sh_quiet)
+                printf("tid%" PRIu64 ": e*10e8=%zd should be %" PRIun "\n", THREAD->tid, (unative_t) (100000000 * e), (unative_t) E_10e8);
+            atomic_inc(&threads_fault);
+            break;
+        }
+    }
+    atomic_inc(&threads_ok);
+}
+static void pi(void *data)
+{
+    int i;
+    double lpi, pi;
+    double n, ab, ad;
+    thread_detach(THREAD);
+    waitq_sleep(&can_start);
+    for (i = 0; i < ATTEMPTS; i++) {
+        lpi = -1;
+        pi = 0;
+        for (n = 2, ab = sqrt(2); lpi != pi; n *= 2, ab = ad) {
+            double sc, cd;
+            sc = sqrt(1 - (ab * ab / 4));
+            cd = 1 - sc;
+            ad = sqrt(ab * ab / 4 + cd * cd);
+            lpi = pi;
+            pi = 2 * n * ad;
+        }
+        if ((int) (100000000 * pi) != PI_10e8) {
+            if (!sh_quiet)
+                printf("tid%" PRIu64 ": pi*10e8=%zd should be %" PRIun "\n", THREAD->tid, (unative_t) (100000000 * pi), (unative_t) PI_10e8);
+            atomic_inc(&threads_fault);
+            break;
+        }
+    }
+    atomic_inc(&threads_ok);
+}
+char * test_fpu1(bool quiet)
+{
+    unsigned int i, total = 0;
+    sh_quiet = quiet;
+    waitq_initialize(&can_start);
+    atomic_set(&threads_ok, 0);
+    atomic_set(&threads_fault, 0);
+    if (!quiet)
+        printf("Creating %u threads... ", 2 * THREADS);
+    for (i = 0; i < THREADS; i++) {
+        thread_t *t;
+        if (!(t = thread_create(e, NULL, TASK, 0, "e", false))) {
+            if (!quiet)
+                printf("could not create thread %u\n", 2 * i);
+            break;
+        }
+        thread_ready(t);
+        total++;
+        if (!(t = thread_create(pi, NULL, TASK, 0, "pi", false))) {
+            if (!quiet)
+                printf("could not create thread %u\n", 2 * i + 1);
+            break;
+        }
+        thread_ready(t);
+        total++;
+    }
+    if (!quiet)
+        printf("ok\n");
+    thread_sleep(1);
+    waitq_wakeup(&can_start, WAKEUP_ALL);
+    while (atomic_get(&threads_ok) != (long) total) {
+        if (!quiet)
+            printf("Threads left: %d\n", total - atomic_get(&threads_ok));
+        thread_sleep(1);
+    }
+    if (atomic_get(&threads_fault) == 0)
+        return NULL;
+    return "Test failed";
+}

 /branches/dynload/kernel/genarch/include/kbd/z8530.h
 ,8 → 49,8
 extern void z8530_release(void);
 extern void z8530_interrupt(void);
 extern char z8530_key_read(chardev_t *);
-extern irq_ownership_t z8530_claim(void);
-extern void z8530_irq_handler(irq_t *, void *, ...);
+extern irq_ownership_t z8530_claim(void *);
+extern void z8530_irq_handler(irq_t *);
 #endif

 /branches/dynload/kernel/genarch/include/kbd/ns16550.h
 ,7 → 37,7
 #ifndef KERN_NS16550_H_
 #define KERN_NS16550_H_
-#include <console/chardev.h>
+#include <console/chardev.h>
 #include <ddi/irq.h>
 #include <ipc/irq.h>
 ,13 → 46,12
 extern void ns16550_grab(void);
 extern void ns16550_release(void);
 extern char ns16550_key_read(chardev_t *);
-extern irq_ownership_t ns16550_claim(void);
-extern void ns16550_irq_handler(irq_t *, void *, ...);
+extern irq_ownership_t ns16550_claim(void *);
+extern void ns16550_irq_handler(irq_t *);
 #include <arch/types.h>
-#ifndef ia64
 #include <arch/drivers/kbd.h>
-#endif
 /* NS16550 registers */
 #define RBR_REG     0    /** Receiver Buffer Register. */
 #define IER_REG     1   /** Interrupt Enable Register. */
 ,56 → 76,56
 static inline uint8_t ns16550_rbr_read(ns16550_t *dev)
 {
-    return inb(dev->io_port + RBR_REG);
+    return pio_read_8(dev->io_port + RBR_REG);
 }
 static inline void ns16550_rbr_write(ns16550_t *dev, uint8_t v)
 {
-    outb(dev->io_port + RBR_REG, v);
+    pio_write_8(dev->io_port + RBR_REG, v);
 }
 static inline uint8_t ns16550_ier_read(ns16550_t *dev)
 {
-    return inb(dev->io_port + IER_REG);
+    return pio_read_8(dev->io_port + IER_REG);
 }
 static inline void ns16550_ier_write(ns16550_t *dev, uint8_t v)
 {
-    outb(dev->io_port + IER_REG, v);
+    pio_write_8(dev->io_port + IER_REG, v);
 }
 static inline uint8_t ns16550_iir_read(ns16550_t *dev)
 {
-    return inb(dev->io_port + IIR_REG);
+    return pio_read_8(dev->io_port + IIR_REG);
 }
 static inline void ns16550_fcr_write(ns16550_t *dev, uint8_t v)
 {
-    outb(dev->io_port + FCR_REG, v);
+    pio_write_8(dev->io_port + FCR_REG, v);
 }
 static inline uint8_t ns16550_lcr_read(ns16550_t *dev)
 {
-    return inb(dev->io_port + LCR_REG);
+    return pio_read_8(dev->io_port + LCR_REG);
 }
 static inline void ns16550_lcr_write(ns16550_t *dev, uint8_t v)
 {
-    outb(dev->io_port + LCR_REG, v);
+    pio_write_8(dev->io_port + LCR_REG, v);
 }
 static inline uint8_t ns16550_lsr_read(ns16550_t *dev)
 {
-    return inb(dev->io_port + LSR_REG);
+    return pio_read_8(dev->io_port + LSR_REG);
 }
 static inline uint8_t ns16550_mcr_read(ns16550_t *dev)
 {
-    return inb(dev->io_port + MCR_REG);
+    return pio_read_8(dev->io_port + MCR_REG);
 }
 static inline void ns16550_mcr_write(ns16550_t *dev, uint8_t v)
 {
-    outb(dev->io_port + MCR_REG, v);
+    pio_write_8(dev->io_port + MCR_REG, v);
 }
 #endif

 /branches/dynload/kernel/genarch/src/kbd/ns16550.c
 ,11 → 138,9
     sysinfo_set_item_val("kbd.address.virtual", NULL, port);
     sysinfo_set_item_val("kbd.port", NULL, port);
-#ifdef CONFIG_NS16550_INTERRUPT_DRIVEN
     /* Enable interrupts */
     ns16550_ier_write(&ns16550, IER_ERBFI);
     ns16550_mcr_write(&ns16550, MCR_OUT2);
-#endif
     uint8_t c;
     // This switches rbr & ier to mode when accept baudrate constant
 ,28 → 196,6
  */
 void ns16550_poll(void)
 {
-#ifndef CONFIG_NS16550_INTERRUPT_DRIVEN
-    ipl_t ipl;
-    ipl = interrupts_disable();
-    spinlock_lock(&ns16550_irq.lock);
-    if (ns16550_lsr_read(&ns16550) & LSR_DATA_READY) {
-        if (ns16550_irq.notif_cfg.notify && ns16550_irq.notif_cfg.answerbox) {
-            /*
-             * Send IPC notification.
-             */
-            ipc_irq_send_notif(&ns16550_irq);
-            spinlock_unlock(&ns16550_irq.lock);
-            interrupts_restore(ipl);
-            return;
-        }
-    }
-    spinlock_unlock(&ns16550_irq.lock);
-    interrupts_restore(ipl);
-#endif
     while (ns16550_lsr_read(&ns16550) & LSR_DATA_READY) {
         uint8_t x;
 ,12 → 210,12
     }
 }
-irq_ownership_t ns16550_claim(void)
+irq_ownership_t ns16550_claim(void *instance)
 {
     return (ns16550_lsr_read(&ns16550) & LSR_DATA_READY);
 }
-void ns16550_irq_handler(irq_t *irq, void *arg, ...)
+void ns16550_irq_handler(irq_t *irq)
 {
     if (irq->notif_cfg.notify && irq->notif_cfg.answerbox)
         ipc_irq_send_notif(irq);

 /branches/dynload/kernel/genarch/src/kbd/i8042.c
 ,12 → 123,12
     interrupts_restore(ipl);
 }
-static irq_ownership_t i8042_claim(void)
+static irq_ownership_t i8042_claim(void *instance)
 {
     return IRQ_ACCEPT;
 }
-static void i8042_irq_handler(irq_t *irq, void *arg, ...)
+static void i8042_irq_handler(irq_t *irq)
 {
     if (irq->notif_cfg.notify && irq->notif_cfg.answerbox)
         ipc_irq_send_notif(irq);

 /branches/dynload/kernel/genarch/src/kbd/z8530.c
 ,12 → 194,12
     }
 }
-irq_ownership_t z8530_claim(void)
+irq_ownership_t z8530_claim(void *instance)
 {
     return (z8530_read_a(&z8530, RR0) & RR0_RCA);
 }
-void z8530_irq_handler(irq_t *irq, void *arg, ...)
+void z8530_irq_handler(irq_t *irq)
 {
     if (irq->notif_cfg.notify && irq->notif_cfg.answerbox)
         ipc_irq_send_notif(irq);

 /branches/dynload/kernel/genarch/src/fb/fb.c
 ,9 → 52,6
 SPINLOCK_INITIALIZE(fb_lock);
-/**< Physical memory area for fb. */
-static parea_t fb_parea;
 static uint8_t *fb_addr;
 static uint8_t *backbuf;
 static uint8_t *glyphs;
 ,12 → 516,6
     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) 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);

 /branches/dynload/kernel/genarch/src/drivers/ega/ega.c
 ,8 → 54,6
  * Simple and short. Function for displaying characters and "scrolling".
  */
-static parea_t ega_parea;   /**< Physical memory area for EGA video RAM. */
 SPINLOCK_INITIALIZE(egalock);
 static uint32_t ega_cursor;
 static uint8_t *videoram;
 ,10 → 81,10
 static void ega_move_cursor(void)
 {
-    outb(ega_base + EGA_INDEX_REG, 0xe);
-    outb(ega_base + EGA_DATA_REG, (uint8_t) ((ega_cursor >> 8) & 0xff));
-    outb(ega_base + EGA_INDEX_REG, 0xf);
-    outb(ega_base + EGA_DATA_REG, (uint8_t) (ega_cursor & 0xff));
+    pio_write_8(ega_base + EGA_INDEX_REG, 0xe);
+    pio_write_8(ega_base + EGA_DATA_REG, (uint8_t) ((ega_cursor >> 8) & 0xff));
+    pio_write_8(ega_base + EGA_INDEX_REG, 0xf);
+    pio_write_8(ega_base + EGA_DATA_REG, (uint8_t) (ega_cursor & 0xff));
 }
 static void ega_display_char(char ch, bool silent)
 ,12 → 150,6
     chardev_initialize("ega_out", &ega_console, &ega_ops);
     stdout = &ega_console;
-    ega_parea.pbase = videoram_phys;
-    ega_parea.vbase = (uintptr_t) videoram;
-    ega_parea.frames = 1;
-    ega_parea.cacheable = false;
-    ddi_parea_register(&ega_parea);
     sysinfo_set_item_val("fb", NULL, true);
     sysinfo_set_item_val("fb.kind", NULL, 2);
     sysinfo_set_item_val("fb.width", NULL, ROW);

 /branches/dynload/kernel/generic/include/config.h
 ,7 → 26,7
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 /** @file
 ,9 → 38,9
 #include <arch/types.h>
 #include <arch/mm/page.h>
-#define STACK_SIZE      PAGE_SIZE
+#define STACK_SIZE  PAGE_SIZE
-#define CONFIG_INIT_TASKS   32
+#define CONFIG_INIT_TASKS  32
 typedef struct {
     uintptr_t addr;
 ,14 → 63,14
 } ballocs_t;
 typedef struct {
-    count_t cpu_count;      /**< Number of processors detected. */
-    volatile count_t cpu_active;    /**< Number of processors that are up and running. */
+    count_t cpu_count;            /**< Number of processors detected. */
+    volatile count_t cpu_active;  /**< Number of processors that are up and running. */
     uintptr_t base;
-    size_t kernel_size;     /**< Size of memory in bytes taken by kernel and stack */
+    size_t kernel_size;           /**< Size of memory in bytes taken by kernel and stack */
-    uintptr_t stack_base;       /**< Base adddress of initial stack */
-    size_t stack_size;      /**< Size of initial stack */
+    uintptr_t stack_base;         /**< Base adddress of initial stack */
+    size_t stack_size;            /**< Size of initial stack */
 } config_t;
 extern config_t config;

 /branches/dynload/kernel/generic/include/proc/program.h
 ,8 → 59,7
 extern int program_create_loader(program_t *p, char *name);
 extern void program_ready(program_t *p);
-extern unative_t sys_program_spawn_loader(int *uspace_phone_id,
-    char *uspace_name, size_t name_len);
+extern unative_t sys_program_spawn_loader(char *uspace_name, size_t name_len);
 #endif

 /branches/dynload/kernel/generic/include/ddi/irq.h
 ,10 → 79,10
 } irq_trigger_t;
 struct irq;
-typedef void (* irq_handler_t)(struct irq *irq, void *arg, ...);
+typedef void (* irq_handler_t)(struct irq *);
 /** Type for function used to clear the interrupt. */
-typedef void (* cir_t)(void *arg, inr_t inr);
+typedef void (* cir_t)(void *, inr_t);
 /** IPC notification config structure.
  *
 ,11 → 139,11
     /** Trigger level of the IRQ. */
     irq_trigger_t trigger;
     /** Claim ownership of the IRQ. */
-    irq_ownership_t (* claim)(void);
+    irq_ownership_t (* claim)(void *);
     /** Handler for this IRQ and device. */
     irq_handler_t handler;
-    /** Argument for the handler. */
-    void *arg;
+    /** Instance argument for the handler and the claim function. */
+    void *instance;
     /** Clear interrupt routine. */
     cir_t cir;
 ,11 → 154,11
     ipc_notif_cfg_t notif_cfg;
 } irq_t;
-extern void irq_init(count_t inrs, count_t chains);
-extern void irq_initialize(irq_t *irq);
-extern void irq_register(irq_t *irq);
-extern irq_t *irq_dispatch_and_lock(inr_t inr);
-extern irq_t *irq_find_and_lock(inr_t inr, devno_t devno);
+extern void irq_init(count_t, count_t);
+extern void irq_initialize(irq_t *);
+extern void irq_register(irq_t *);
+extern irq_t *irq_dispatch_and_lock(inr_t);
+extern irq_t *irq_find_and_lock(inr_t, devno_t);
 #endif

 /branches/dynload/kernel/generic/include/ddi/ddi.h
 ,13 → 38,14
 #include <ddi/ddi_arg.h>
 #include <arch/types.h>
 #include <proc/task.h>
+#include <adt/list.h>
 /** Structure representing contiguous physical memory area. */
 typedef struct {
-    uintptr_t pbase;    /**< Physical base of the area. */
-    uintptr_t vbase;    /**< Virtual base of the area. */
-    count_t frames;     /**< Number of frames in the area. */
-    bool cacheable;     /**< Cacheability. */
+    uintptr_t pbase;    /**< Physical base of the area. */
+    pfn_t frames;       /**< Number of frames in the area. */
+    link_t link;        /**< Linked list link */
 } parea_t;
 extern void ddi_init(void);

 /branches/dynload/kernel/generic/include/arch.h
 ,12 → 63,11
     as_t *as;           /**< Current address space. */
 } the_t;
-#define THE     ((the_t *)(get_stack_base()))
+#define THE  ((the_t * )(get_stack_base()))
 extern void the_initialize(the_t *the);
 extern void the_copy(the_t *src, the_t *dst);
-extern void arch_pre_main(void);
 extern void arch_pre_mm_init(void);
 extern void arch_post_mm_init(void);
 extern void arch_post_cpu_init(void);

 /branches/dynload/kernel/generic/include/mm/page.h
 ,7 → 42,7
 /** Operations to manipulate page mappings. */
 typedef struct {
     void (* mapping_insert)(as_t *as, uintptr_t page, uintptr_t frame,
-        int flags);
+        int flags);
     void (* mapping_remove)(as_t *as, uintptr_t page);
     pte_t *(* mapping_find)(as_t *as, uintptr_t page);
 } page_mapping_operations_t;
 ,7 → 59,9
 extern pte_t *page_table_create(int flags);
 extern void page_table_destroy(pte_t *page_table);
 extern void map_structure(uintptr_t s, size_t size);
 extern uintptr_t hw_map(uintptr_t physaddr, size_t size);
+extern void hw_area(uintptr_t *physaddr, pfn_t *frames);
 #endif

 /branches/dynload/kernel/generic/include/macros.h
 ,7 → 26,7
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 /** @file
 ,44 → 37,47
 #include <arch/types.h>
-#define isdigit(d)  (((d) >= '0') && ((d) <= '9'))
-#define islower(c)  (((c) >= 'a') && ((c) <= 'z'))
-#define isupper(c)  (((c) >= 'A') && ((c) <= 'Z'))
-#define isalpha(c)  (is_lower((c)) || is_upper((c)))
-#define isalphanum(c)   (is_alpha((c)) || is_digit((c)))
-#define isspace(c)  (((c) == ' ') || ((c) == '\t') || ((c) == '\n') || \
-                ((c) == '\r'))
+#define isdigit(d)     (((d) >= '0') && ((d) <= '9'))
+#define islower(c)     (((c) >= 'a') && ((c) <= 'z'))
+#define isupper(c)     (((c) >= 'A') && ((c) <= 'Z'))
+#define isalpha(c)     (is_lower((c)) || is_upper((c)))
+#define isalphanum(c)  (is_alpha((c)) || is_digit((c)))
+#define isspace(c) \
+    (((c) == ' ') || ((c) == '\t') || ((c) == '\n') || ((c) == '\r'))
-#define min(a, b)   ((a) < (b) ? (a) : (b))
-#define max(a, b)   ((a) > (b) ? (a) : (b))
+#define min(a, b)  ((a) < (b) ? (a) : (b))
+#define max(a, b)  ((a) > (b) ? (a) : (b))
+#define min3(a, b, c)  ((a) < (b) ? (min(a, c)) : (min(b, c)))
+#define max3(a, b, c)  ((a) > (b) ? (max(a, c)) : (max(b, c)))
 /** Return true if the intervals overlap.
  *
- * @param s1        Start address of the first interval.
- * @param sz1       Size of the first interval.
- * @param s2        Start address of the second interval.
- * @param sz2       Size of the second interval.
+ * @param s1  Start address of the first interval.
+ * @param sz1 Size of the first interval.
+ * @param s2  Start address of the second interval.
+ * @param sz2 Size of the second interval.
  */
 static inline int overlaps(uintptr_t s1, size_t sz1, uintptr_t s2, size_t sz2)
 {
     uintptr_t e1 = s1 + sz1;
     uintptr_t e2 = s2 + sz2;
-    return (s1 < e2) && (s2 < e1);
+    return ((s1 < e2) && (s2 < e1));
 }
 /* Compute overlapping of physical addresses */
-#define PA_overlaps(x, szx, y, szy) \
+#define PA_overlaps(x, szx, y, szy) \
     overlaps(KA2PA((x)), (szx), KA2PA((y)), (szy))
-#define SIZE2KB(size) ((size) >> 10)
-#define SIZE2MB(size) ((size) >> 20)
+#define SIZE2KB(size)  ((size) >> 10)
+#define SIZE2MB(size)  ((size) >> 20)
-#define KB2SIZE(kb) ((kb) << 10)
-#define MB2SIZE(mb) ((mb) << 20)
+#define KB2SIZE(kb)  ((kb) << 10)
+#define MB2SIZE(mb)  ((mb) << 20)
-#define STRING(arg) STRING_ARG(arg)
-#define STRING_ARG(arg) #arg
+#define STRING(arg)      STRING_ARG(arg)
+#define STRING_ARG(arg)  #arg
 /** Pseudorandom generator
  *

 /branches/dynload/kernel/generic/src/time/clock.c
 ,9 → 88,7
     uptime->useconds = 0;
     clock_parea.pbase = (uintptr_t) faddr;
-    clock_parea.vbase = (uintptr_t) uptime;
     clock_parea.frames = 1;
-    clock_parea.cacheable = true;
     ddi_parea_register(&clock_parea);
     /*

 /branches/dynload/kernel/generic/src/ddi/ddi.c
 ,7 → 47,7
 #include <mm/as.h>
 #include <synch/spinlock.h>
 #include <syscall/copy.h>
-#include <adt/btree.h>
+#include <adt/list.h>
 #include <arch.h>
 #include <align.h>
 #include <errno.h>
 ,13 → 55,17
 /** This lock protects the parea_btree. */
 SPINLOCK_INITIALIZE(parea_lock);
-/** B+tree with enabled physical memory areas. */
-static btree_t parea_btree;
+/** List with enabled physical memory areas. */
+static LIST_INITIALIZE(parea_head);
+/** Physical memory area for devices. */
+static parea_t dev_area;
 /** Initialize DDI. */
 void ddi_init(void)
 {
-    btree_create(&parea_btree);
+    hw_area(&dev_area.pbase, &dev_area.frames);
+    ddi_parea_register(&dev_area);
 }
 /** Enable piece of physical memory for mapping by physmem_map().
 ,19 → 78,19
 void ddi_parea_register(parea_t *parea)
 {
     ipl_t ipl;
     ipl = interrupts_disable();
     spinlock_lock(&parea_lock);
     /*
      * TODO: we should really check for overlaps here.
-     * However, we should be safe because the kernel is pretty sane and
-     * memory of different devices doesn't overlap.
+     * However, we should be safe because the kernel is pretty sane.
      */
-    btree_insert(&parea_btree, (btree_key_t) parea->pbase, parea, NULL);
+    link_initialize(&parea->link);
+    list_append(&parea->link, &parea_head);
     spinlock_unlock(&parea_lock);
-    interrupts_restore(ipl);
+    interrupts_restore(ipl);
 }
 /** Map piece of physical memory into virtual address space of current task.
 ,16 → 101,16
  * @param flags Address space area flags for the mapping.
  *
  * @return 0 on success, EPERM if the caller lacks capabilities to use this
- *  syscall, ENOENT if there is no task matching the specified ID or the
- *  physical address space is not enabled for mapping and ENOMEM if there
- *  was a problem in creating address space area.
+ *  syscall, ENOENT if there is no task matching the specified ID or the
+ *  physical address space is not enabled for mapping and ENOMEM if there
+ *  was a problem in creating address space area.
  */
-static int ddi_physmem_map(uintptr_t pf, uintptr_t vp, count_t pages, int flags)
+static int ddi_physmem_map(uintptr_t pf, uintptr_t vp, pfn_t pages, int flags)
 {
     ipl_t ipl;
     cap_t caps;
     mem_backend_data_t backend_data;
     backend_data.base = pf;
     backend_data.frames = pages;
 ,30 → 120,35
     caps = cap_get(TASK);
     if (!(caps & CAP_MEM_MANAGER))
         return EPERM;
     ipl = interrupts_disable();
     /*
      * Check if the physical memory area is enabled for mapping.
-     * If the architecture supports virtually indexed caches, intercept
-     * attempts to create an illegal address alias.
      */
     spinlock_lock(&parea_lock);
-    parea_t *parea;
-    btree_node_t *nodep;
-    parea = (parea_t *) btree_search(&parea_btree, (btree_key_t) pf, &nodep);
-    if (!parea || parea->frames < pages || ((flags & AS_AREA_CACHEABLE) &&
-        !parea->cacheable) || (!(flags & AS_AREA_CACHEABLE) &&
-        parea->cacheable)) {
+    bool fnd = false;
+    link_t *cur;
+    for (cur = parea_head.next; cur != &parea_head; cur = cur->next) {
+        parea_t *parea = list_get_instance(cur, parea_t, link);
+        if ((parea->pbase <= pf) && (ADDR2PFN(pf - parea->pbase) + pages <= parea->frames)) {
+            fnd = true;
+            break;
+        }
+    }
+    spinlock_unlock(&parea_lock);
+    if (!fnd) {
         /*
-         * This physical memory area cannot be mapped.
+         * Physical memory area cannot be mapped.
          */
-        spinlock_unlock(&parea_lock);
         interrupts_restore(ipl);
         return ENOENT;
     }
-    spinlock_unlock(&parea_lock);
     spinlock_lock(&TASK->lock);
     if (!as_area_create(TASK->as, flags, pages * PAGE_SIZE, vp, AS_AREA_ATTR_NONE,
 ,7 → 235,7
 {
     return (unative_t) ddi_physmem_map(ALIGN_DOWN((uintptr_t) phys_base,
         FRAME_SIZE), ALIGN_DOWN((uintptr_t) virt_base, PAGE_SIZE),
-        (count_t) pages, (int) flags);
+        (pfn_t) pages, (int) flags);
 }
 /** Wrapper for SYS_ENABLE_IOSPACE syscall.
 ,13 → 267,13
  */
 unative_t sys_preempt_control(int enable)
 {
-        if (!cap_get(TASK) & CAP_PREEMPT_CONTROL)
-                return EPERM;
-        if (enable)
-                preemption_enable();
-        else
-                preemption_disable();
-        return 0;
+    if (!cap_get(TASK) & CAP_PREEMPT_CONTROL)
+        return EPERM;
+    if (enable)
+        preemption_enable();
+    else
+        preemption_disable();
+    return 0;
 }
 /** @}

 /branches/dynload/kernel/generic/src/ddi/irq.c
 ,7 → 39,8
  *
  * This code is designed to support:
  * - multiple devices sharing single IRQ
- * - multiple IRQs per signle device
+ * - multiple IRQs per single device
+ * - multiple instances of the same device
  *
  *
  * Note about architectures.
 ,7 → 145,7
     irq->trigger = (irq_trigger_t) 0;
     irq->claim = NULL;
     irq->handler = NULL;
-    irq->arg = NULL;
+    irq->instance = NULL;
     irq->cir = NULL;
     irq->cir_arg = NULL;
     irq->notif_cfg.notify = false;
 ,7 → 307,8
     spinlock_lock(&irq->lock);
     if (devno == -1) {
         /* Invoked by irq_dispatch_and_lock(). */
-        rv = ((irq->inr == inr) && (irq->claim() == IRQ_ACCEPT));
+        rv = ((irq->inr == inr) &&
+            (irq->claim(irq->instance) == IRQ_ACCEPT));
     } else {
         /* Invoked by irq_find_and_lock(). */
         rv = ((irq->inr == inr) && (irq->devno == devno));
 ,7 → 367,7
     spinlock_lock(&irq->lock);
     if (devno == -1) {
         /* Invoked by irq_dispatch_and_lock() */
-        rv = (irq->claim() == IRQ_ACCEPT);
+        rv = (irq->claim(irq->instance) == IRQ_ACCEPT);
     } else {
         /* Invoked by irq_find_and_lock() */
         rv = (irq->devno == devno);

 /branches/dynload/kernel/generic/src/console/console.c
 ,7 → 101,7
  *
  * @return Always returns IRQ_DECLINE.
  */
-static irq_ownership_t klog_claim(void)
+static irq_ownership_t klog_claim(void *instance)
 {
     return IRQ_DECLINE;
 }
 ,9 → 126,7
     devno_t devno = device_assign_devno();
     klog_parea.pbase = (uintptr_t) faddr;
-    klog_parea.vbase = (uintptr_t) klog;
     klog_parea.frames = SIZE2FRAMES(KLOG_SIZE);
-    klog_parea.cacheable = true;
     ddi_parea_register(&klog_parea);
     sysinfo_set_item_val("klog.faddr", NULL, (unative_t) faddr);

 /branches/dynload/kernel/generic/src/console/cmd.c
 ,7 → 529,7
         spinlock_unlock(&hlp->lock);
     }
-    spinlock_unlock(&cmd_lock);
+    spinlock_unlock(&cmd_lock);
     return 1;
 }

 /branches/dynload/kernel/generic/src/console/kconsole.c
 ,7 → 103,7
  * @return Always returns IRQ_DECLINE.
  *
  */
-static irq_ownership_t kconsole_claim(void)
+static irq_ownership_t kconsole_claim(void *instance)
 {
     return IRQ_DECLINE;
 }

 /branches/dynload/kernel/generic/src/proc/task.c
 ,7 → 339,7
         bool sleeping = false;
         thr = list_get_instance(cur, thread_t, th_link);
         spinlock_lock(&thr->lock);
         thr->interrupted = true;
         if (thr->state == Sleeping)

 /branches/dynload/kernel/generic/src/proc/program.c
 ,32 → 184,20
 /** Syscall for creating a new loader instance from userspace.
  *
- * Creates a new task from the program loader image, connects a phone
- * to it and stores the phone id into the provided buffer.
+ * Creates a new task from the program loader image and sets
+ * the task name.
  *
- * @param uspace_phone_id   Userspace address where to store the phone id.
  * @param name          Name to set on the new task (typically the same
  *              as the command used to execute it).
  *
  * @return 0 on success or an error code from @ref errno.h.
  */
-unative_t sys_program_spawn_loader(int *uspace_phone_id, char *uspace_name,
-    size_t name_len)
+unative_t sys_program_spawn_loader(char *uspace_name, size_t name_len)
 {
     program_t p;
-    int fake_id;
     int rc;
-    int phone_id;
     char namebuf[TASK_NAME_BUFLEN];
-    fake_id = 0;
-    /* Before we even try creating the task, see if we can write the id */
-    rc = (unative_t) copy_to_uspace(uspace_phone_id, &fake_id,
-        sizeof(fake_id));
-    if (rc != 0)
-        return rc;
     /* Cap length of name and copy it from userspace. */
     if (name_len > THREAD_NAME_BUFLEN - 1)
 ,12 → 209,6
     namebuf[name_len] = '\0';
-    /* Allocate the phone for communicating with the new task. */
-    phone_id = phone_alloc();
-    if (phone_id < 0)
-        return ELIMIT;
     /* Spawn the new task. */
     rc = program_create_loader(&p, namebuf);
 ,18 → 215,6
     if (rc != 0)
         return rc;
-    phone_connect(phone_id, &p.task->answerbox);
-    /* No need to aquire lock before task_ready() */
-    rc = (unative_t) copy_to_uspace(uspace_phone_id, &phone_id,
-        sizeof(phone_id));
-    if (rc != 0) {
-        /* Ooops */
-        ipc_phone_hangup(&TASK->phones[phone_id]);
-        task_kill(p.task->taskid);
-        return rc;
-    }
     // FIXME: control the capabilities
     cap_set(p.task, cap_get(TASK));

 /branches/dynload/kernel/generic/src/lib/rd.c
 ,9 → 88,7
     rd_parea.pbase = ALIGN_DOWN((uintptr_t) KA2PA((void *) header + hsize),
         FRAME_SIZE);
-    rd_parea.vbase = (uintptr_t) ((void *) header + hsize);
     rd_parea.frames = SIZE2FRAMES(dsize);
-    rd_parea.cacheable = true;
     ddi_parea_register(&rd_parea);
     sysinfo_set_item_val("rd", NULL, true);

 /branches/dynload/kernel/generic/src/adt/avl.c
 ,7 → 43,7
  *
  * Every node has a pointer to its parent which allows insertion of multiple
  * identical keys into the tree.
- *
+ *
  * Be careful when using this tree because of the base atribute which is added
  * to every inserted node key. There is no rule in which order nodes with the
  * same key are visited.

 /branches/dynload/kernel/generic/src/mm/as.c
 ,7 → 122,7
     int rc;
     link_initialize(&as->inactive_as_with_asid_link);
-    mutex_initialize(&as->lock, MUTEX_PASSIVE);
+    mutex_initialize(&as->lock, MUTEX_PASSIVE);
     rc = as_constructor_arch(as, flags);

 /branches/dynload/kernel/generic/src/ipc/irq.c
 ,10 → 101,10
                 code->cmds[i].value;
             break;
         case CMD_PORT_READ_1:
-            dstval = inb((long) code->cmds[i].addr);
+            dstval = pio_read_8((long) code->cmds[i].addr);
             break;
         case CMD_PORT_WRITE_1:
-            outb((long) code->cmds[i].addr, code->cmds[i].value);
+            pio_write_8((long) code->cmds[i].addr, code->cmds[i].value);
             break;
         default:
             break;

 /branches/dynload/kernel/Makefile
 ,7 → 246,6
         test/atomic/atomic1.c \
         test/btree/btree1.c \
         test/avltree/avltree1.c \
-        test/debug/mips1.c \
         test/fault/fault1.c \
         test/mm/falloc1.c \
         test/mm/falloc2.c \
 ,7 → 252,6
         test/mm/mapping1.c \
         test/mm/slab1.c \
         test/mm/slab2.c \
-        test/mm/purge1.c \
         test/synch/rwlock1.c \
         test/synch/rwlock2.c \
         test/synch/rwlock3.c \
 ,19 → 263,34
         test/thread/thread1.c \
         test/sysinfo/sysinfo1.c
+    ifeq ($(KARCH),mips32)
+        GENERIC_SOURCES += test/debug/mips1.c
+    else
+        GENERIC_SOURCES += test/debug/mips1_skip.c
+    endif
+    ifeq ($(KARCH),ia64)
+        GENERIC_SOURCES += test/mm/purge1.c
+    else
+        GENERIC_SOURCES += test/mm/purge1_skip.c
+    endif
     ifeq ($(CONFIG_FPU),y)
         ifeq ($(KARCH),ia32)
             TEST_FPU1 = y
             TEST_SSE1 = y
+            GENERIC_SOURCES += test/fpu/fpu1_x86.c
         endif
         ifeq ($(KARCH),amd64)
             TEST_FPU1 = y
             TEST_SSE1 = y
+            GENERIC_SOURCES += test/fpu/fpu1_x86.c
         endif
         ifeq ($(KARCH),ia64)
             TEST_FPU1 = y
+            GENERIC_SOURCES += test/fpu/fpu1_ia64.c
         endif
         ifeq ($(KARCH),mips32)
 ,9 → 298,7
         endif
     endif
-    ifeq ($(TEST_FPU1),y)
-        GENERIC_SOURCES += test/fpu/fpu1.c
-    else
+    ifneq ($(TEST_FPU1),y)
         GENERIC_SOURCES += test/fpu/fpu1_skip.c
     endif

/branches/dynload/kernel/arch/sparc64/include/cpu_node.h
55,4 → 55,5
#endif

/** @}
*/
*/

 /branches/dynload/kernel/arch/sparc64/include/arch.h
 ,6 → 45,12
 #define NWINDOWS        8   /** Number of register window sets. */
+#ifndef __ASM__
+extern void arch_pre_main(void);
+#endif /* __ASM__ */
 #endif
 /** @}

 /branches/dynload/kernel/arch/sparc64/include/asm.h
 ,25 → 44,25
 #include <arch/stack.h>
 #include <arch/barrier.h>
-static inline void outb(ioport_t port, uint8_t v)
+static inline void pio_write_8(ioport_t port, uint8_t v)
 {
     *((volatile uint8_t *)(port)) = v;
     memory_barrier();
 }
-static inline void outw(ioport_t port, uint16_t v)
+static inline void pio_write_16(ioport_t port, uint16_t v)
 {
     *((volatile uint16_t *)(port)) = v;
     memory_barrier();
 }
-static inline void outl(ioport_t port, uint32_t v)
+static inline void pio_write_32(ioport_t port, uint32_t v)
 {
     *((volatile uint32_t *)(port)) = v;
     memory_barrier();
 }
-static inline uint8_t inb(ioport_t port)
+static inline uint8_t pio_read_8(ioport_t port)
 {
     uint8_t rv;
 ,7 → 72,7
     return rv;
 }
-static inline uint16_t inw(ioport_t port)
+static inline uint16_t pio_read_16(ioport_t port)
 {
     uint16_t rv;
 ,7 → 82,7
     return rv;
 }
-static inline uint32_t inl(ioport_t port)
+static inline uint32_t pio_read_32(ioport_t port)
 {
     uint32_t rv;

/branches/dynload/kernel/arch/sparc64/include/mm/frame.h
73,6 → 73,7
typedef union frame_address frame_address_t;

extern uintptr_t last_frame;
extern uintptr_t end_frame;
extern void frame_arch_init(void);
#define physmem_print()

/branches/dynload/kernel/arch/sparc64/include/cpu_family.h
79,4 → 79,5
#endif

/** @}
*/
*/

 /branches/dynload/kernel/arch/sparc64/src/console.c
 ,32 → 141,10
 {
     thread_detach(THREAD);
-#ifdef CONFIG_Z8530
-    if (kbd_type == KBD_Z8530) {
-        /*
-         * The z8530 driver is interrupt-driven.
-         */
+    if (kbd_type != KBD_SGCN)
         return;
-    }
-#endif
-#ifdef CONFIG_NS16550
-#ifdef CONFIG_NS16550_INTERRUPT_DRIVEN
-    if (kbd_type == KBD_NS16550) {
-        /*
-         * The ns16550 driver is interrupt-driven.
-         */
-        return;
-    }
-#endif
-#endif
     while (1) {
-#ifdef CONFIG_NS16550
-#ifndef CONFIG_NS16550_INTERRUPT_DRIVEN
-        if (kbd_type == KBD_NS16550)
-            ns16550_poll();
-#endif
-#endif
 #ifdef CONFIG_SGCN
         if (kbd_type == KBD_SGCN)
             sgcn_poll();

/branches/dynload/kernel/arch/sparc64/src/sparc64.c
103,7 → 103,6
{
static thread_t *t = NULL;


if (!t) {
/*
* Create thread that polls keyboard.

 /branches/dynload/kernel/arch/sparc64/src/trap/interrupt.c
 ,7 → 86,7
         /*
          * The IRQ handler was found.
          */
-        irq->handler(irq, irq->arg);
+        irq->handler(irq);
         /*
          * See if there is a clear-interrupt-routine and call it.
          */

/branches/dynload/kernel/arch/sparc64/src/mm/frame.c
41,6 → 41,7
#include <macros.h>

uintptr_t last_frame = NULL;
uintptr_t end_frame = NULL;

/** Create memory zones according to information stored in bootinfo.
*
80,6 → 81,7
frame_mark_unavailable(ADDR2PFN(KA2PA(PFN2ADDR(0))), 1);
}

end_frame = last_frame;
}

/** @}

 /branches/dynload/kernel/arch/sparc64/src/mm/page.c
 ,7 → 147,7
             physaddr + i * sizemap[order].increment,
             sizemap[order].pagesize_code, true, false);
-#ifdef CONFIG_SMP
+#ifdef CONFIG_SMP
         /*
          * Second, save the information about the mapping for APs.
          */
 ,6 → 164,11
     return virtaddr;
 }
+void hw_area(uintptr_t *physaddr, pfn_t *frames)
+{
+    *physaddr = end_frame;
+    *frames = ADDR2PFN(0x7ffffffffff - end_frame);
+}
 /** @}
  */

 /branches/dynload/kernel/arch/sparc64/src/drivers/sgcn.c
 ,19 → 161,10
 chardev_t sgcn_io;
 /**
- * Registers the physical area of the SRAM so that the userspace SGCN
- * driver can map it. Moreover, it sets some sysinfo values (SRAM address
- * and SRAM size).
+ * Set some sysinfo values (SRAM address and SRAM size).
  */
-static void register_sram_parea(uintptr_t sram_begin_physical)
+static void register_sram(uintptr_t sram_begin_physical)
 {
-    static parea_t sram_parea;
-    sram_parea.pbase = sram_begin_physical;
-    sram_parea.vbase = (uintptr_t) sram_begin;
-    sram_parea.frames = MAPPED_AREA_SIZE / FRAME_SIZE;
-    sram_parea.cacheable = false;
-    ddi_parea_register(&sram_parea);
     sysinfo_set_item_val("sram.area.size", NULL, MAPPED_AREA_SIZE);
     sysinfo_set_item_val("sram.address.physical", NULL,
         sram_begin_physical);
 ,7 → 202,7
         + *((uint32_t *) iosram_toc->value);
     sram_begin = hw_map(sram_begin_physical, MAPPED_AREA_SIZE);
-    register_sram_parea(sram_begin_physical);
+    register_sram(sram_begin_physical);
 }
 /**
 ,7 → 310,7
 /**
  * The driver works in polled mode, so no interrupt should be handled by it.
  */
-static irq_ownership_t sgcn_claim(void)
+static irq_ownership_t sgcn_claim(void *instance)
 {
     return IRQ_DECLINE;
 }
 ,7 → 318,7
 /**
  * The driver works in polled mode, so no interrupt should be handled by it.
  */
-static void sgcn_irq_handler(irq_t *irq, void *arg, ...)
+static void sgcn_irq_handler(irq_t *irq)
 {
     panic("Not yet implemented, SGCN works in polled mode.");
 }

 /branches/dynload/kernel/arch/ia64/include/arch.h
 ,6 → 39,8
 #include <arch/ski/ski.h>
+extern void arch_pre_main(void);
 #endif
 /** @}

 /branches/dynload/kernel/arch/ia64/include/asm.h
 ,7 → 41,7
 #define IA64_IOSPACE_ADDRESS 0xE001000000000000ULL
-static inline void outb(ioport_t port, uint8_t v)
+static inline void pio_write_8(ioport_t port, uint8_t v)
 {
     *((uint8_t *)(IA64_IOSPACE_ADDRESS +
         ((port & 0xfff) | ((port >> 2) << 12)))) = v;
 ,7 → 49,7
     asm volatile ("mf\n" ::: "memory");
 }
-static inline void outw(ioport_t port, uint16_t v)
+static inline void pio_write_16(ioport_t port, uint16_t v)
 {
     *((uint16_t *)(IA64_IOSPACE_ADDRESS +
         ((port & 0xfff) | ((port >> 2) << 12)))) = v;
 ,7 → 57,7
     asm volatile ("mf\n" ::: "memory");
 }
-static inline void outl(ioport_t port, uint32_t v)
+static inline void pio_write_32(ioport_t port, uint32_t v)
 {
     *((uint32_t *)(IA64_IOSPACE_ADDRESS +
         ((port & 0xfff) | ((port >> 2) << 12)))) = v;
 ,7 → 65,7
     asm volatile ("mf\n" ::: "memory");
 }
-static inline uint8_t inb(ioport_t port)
+static inline uint8_t pio_read_8(ioport_t port)
 {
     asm volatile ("mf\n" ::: "memory");
 ,7 → 73,7
         ((port & 0xfff) | ((port >> 2) << 12))));
 }
-static inline uint16_t inw(ioport_t port)
+static inline uint16_t pio_read_16(ioport_t port)
 {
     asm volatile ("mf\n" ::: "memory");
 ,7 → 81,7
         ((port & 0xffE) | ((port >> 2) << 12))));
 }
-static inline uint32_t inl(ioport_t port)
+static inline uint32_t pio_read_32(ioport_t port)
 {
     asm volatile ("mf\n" ::: "memory");

/branches/dynload/kernel/arch/ia64/include/mm/frame.h
44,6 → 44,7
#include <arch/types.h>

extern uintptr_t last_frame;
extern uintptr_t end_frame;

extern void frame_arch_init(void);
#define physmem_print()

 /branches/dynload/kernel/arch/ia64/include/drivers/i8042.h
 ,22 → 47,22
 static inline void i8042_data_write(uint8_t data)
 {
-    outb(i8042_DATA, data);
+    pio_write_8(i8042_DATA, data);
 }
 static inline uint8_t i8042_data_read(void)
 {
-    return inb(i8042_DATA);
+    return pio_read_8(i8042_DATA);
 }
 static inline uint8_t i8042_status_read(void)
 {
-    return inb(i8042_STATUS);
+    return pio_read_8(i8042_STATUS);
 }
 static inline void i8042_command_write(uint8_t command)
 {
-    outb(i8042_STATUS, command);
+    pio_write_8(i8042_STATUS, command);
 }
 #endif

 /branches/dynload/kernel/arch/ia64/src/ia64.c
 ,36 → 148,13
 {
 }
-#ifdef I460GX
-#define POLL_INTERVAL       50000       /* 50 ms */
-/** Kernel thread for polling keyboard. */
-static void i8042_kkbdpoll(void *arg)
-{
-    while (1) {
-#ifdef CONFIG_NS16550
-    #ifndef CONFIG_NS16550_INTERRUPT_DRIVEN
-        ns16550_poll();
-    #endif
-#else
-    #ifndef CONFIG_I8042_INTERRUPT_DRIVEN
-        i8042_poll();
-    #endif
-#endif
-        thread_usleep(POLL_INTERVAL);
-    }
-}
-#endif
 void arch_post_smp_init(void)
 {
-    thread_t *t;
     /*
      * Create thread that polls keyboard.
      */
 #ifdef SKI
-    t = thread_create(kkbdpoll, NULL, TASK, 0, "kkbdpoll", true);
+    thread_t *t = thread_create(kkbdpoll, NULL, TASK, 0, "kkbdpoll", true);
     if (!t)
         panic("Cannot create kkbdpoll.");
     thread_ready(t);
 ,10 → 169,6
     devno_t mouse = device_assign_devno();
     i8042_init(kbd, IRQ_KBD, mouse, IRQ_MOUSE);
 #endif
-    t = thread_create(i8042_kkbdpoll, NULL, TASK, 0, "kkbdpoll", true);
-    if (!t)
-        panic("Cannot create kkbdpoll.");
-    thread_ready(t);
 #endif
     sysinfo_set_item_val("ia64_iospace", NULL, true);
 ,7 → 249,7
 void arch_reboot(void)
 {
-    outb(0x64, 0xfe);
+    pio_write_8(0x64, 0xfe);
     while (1)
         ;
 }

 /branches/dynload/kernel/arch/ia64/src/ski/ski.c
 ,7 → 186,7
  *
  * @return Always IRQ_DECLINE.
  */
-static irq_ownership_t ski_kbd_claim(void)
+static irq_ownership_t ski_kbd_claim(void *instance)
 {
     return IRQ_DECLINE;
 }

/branches/dynload/kernel/arch/ia64/src/mm/frame.c
51,6 → 51,7
#define MINCONF 1

uintptr_t last_frame = 0;
uintptr_t end_frame = 0;

void frame_arch_init(void)
{

 /branches/dynload/kernel/arch/ia64/src/mm/page.c
 ,5 → 274,11
     return PA2KA(physaddr);
 }
+void hw_area(uintptr_t *physaddr, pfn_t *frames)
+{
+    *physaddr = end_frame;
+    *frames = ADDR2PFN(0x7fffffffffffffffUL - end_frame);
+}
 /** @}
  */

 /branches/dynload/kernel/arch/ia64/src/interrupt.c
 ,7 → 266,7
     case INTERRUPT_TIMER:
         irq = irq_dispatch_and_lock(ivr.vector);
         if (irq) {
-            irq->handler(irq, irq->arg);
+            irq->handler(irq);
             spinlock_unlock(&irq->lock);
         } else {
             panic("Unhandled Internal Timer Interrupt (%d).",
 ,7 → 283,7
                 /* Send EOI before processing the interrupt */
                 end_of_local_irq();
             }
-            irq->handler(irq, irq->arg);
+            irq->handler(irq);
             if (!irq->preack)
                 end_of_local_irq();
             spinlock_unlock(&irq->lock);

 /branches/dynload/kernel/arch/ia64/src/drivers/it.c
 ,8 → 56,8
 static irq_t it_irq;
-static irq_ownership_t it_claim(void);
-static void it_interrupt(irq_t *irq, void *arg, ...);
+static irq_ownership_t it_claim(void *);
+static void it_interrupt(irq_t *irq);
 /** Initialize Interval Timer. */
 void it_init(void)
 ,13 → 104,13
  *
  * @return Always IRQ_ACCEPT.
  */
-irq_ownership_t it_claim(void)
+irq_ownership_t it_claim(void *instance)
 {
     return IRQ_ACCEPT;
 }
 /** Process Interval Timer interrupt. */
-void it_interrupt(irq_t *irq, void *arg, ...)
+void it_interrupt(irq_t *irq)
 {
     int64_t c;
     int64_t m;

 /branches/dynload/kernel/arch/arm32/_link.ld.in
 ,15 → 1,16
 /*
- *  ARM linker script
- *
+ * ARM linker script
+ *
  *  kernel text
  *  kernel data
- *
+ *
  */
+#define KERNEL_LOAD_ADDRESS 0x80200000
 OUTPUT_ARCH(arm)
-ENTRY(kernel_image_start)
+ENTRY(kernel_image_start)
 SECTIONS {
     . = KERNEL_LOAD_ADDRESS;
     .text : {
 ,29 → 20,29
     }
     .data : {
         kdata_start = .;
-        *(.data);       /* initialized data */
+        *(.data);                       /* initialized data */
         hardcoded_ktext_size = .;
-        LONG(ktext_end - ktext_start);
+        LONG(ktext_end - ktext_start);
         hardcoded_kdata_size = .;
         LONG(kdata_end - kdata_start);
         hardcoded_load_address = .;
         LONG(KERNEL_LOAD_ADDRESS);
-        *(.bss);        /* uninitialized static variables */
-        *(COMMON);      /* global variables */
+        *(.bss);                        /* uninitialized static variables */
+        *(COMMON);                      /* global variables */
         *(.rodata*);
         *(.sdata);
         *(.reginfo);
         symbol_table = .;
-        *(symtab.*);
+        *(symtab.*);
     }
     .sbss : {
         *(.sbss);
         *(.scommon);
     }
     kdata_end = .;
     /DISCARD/ : {
       *(.mdebug*);
       *(.pdr);
 ,5 → 49,4
       *(.comment);
       *(.note);
     }
 }

 /branches/dynload/kernel/arch/arm32/include/asm/boot.h
 ,7 → 26,7
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup arm32
+/** @addtogroup arm32
  * @{
  */
 /** @file
 ,24 → 39,7
 /** Size of a temporary stack used for initial kernel start. */
 #define TEMP_STACK_SIZE 0x100
-#ifndef __ASM__
-/** Kernel entry point.
- *
- * Implemented in assembly. Copies boot_bootinfo (declared as bootinfo in
- * boot/arch/arm32/loader/main.c) to #bootinfo struct. Then jumps to
- * #arch_pre_main and #main_bsp.
- *
- * @param entry          Entry point address (not used).
- * @param boot_bootinfo  Struct holding information about loaded tasks.
- * @param bootinfo_size  Size of the bootinfo structure.
- */
-extern void kernel_image_start(void *entry, void *boot_bootinfo,
-    unsigned int bootinfo_size);
 #endif
-#endif
 /** @}
  */

 /branches/dynload/kernel/arch/arm32/include/machine.h
 ,7 → 102,7
 extern uintptr_t machine_get_fb_address(void);
-#ifdef MACHINE_GXEMUL_TESTARM
+#ifdef MACHINE_gxemul
     #define machine_console_init(devno)            gxemul_console_init(devno)
     #define machine_grab_console                   gxemul_grab_console
     #define machine_release_console                gxemul_release_console

 /branches/dynload/kernel/arch/arm32/include/arch.h
 ,7 → 26,7
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup arm32
+/** @addtogroup arm32
  * @{
  */
 /** @file
 ,6 → 36,23
 #ifndef KERN_arm32_ARCH_H_
 #define KERN_arm32_ARCH_H_
+#define TASKMAP_MAX_RECORDS  32
+#define CPUMAP_MAX_RECORDS   32
+#include <typedefs.h>
+typedef struct {
+    uintptr_t addr;
+    uint32_t size;
+} utask_t;
+typedef struct {
+    uint32_t cnt;
+    utask_t tasks[TASKMAP_MAX_RECORDS];
+} bootinfo_t;
+extern void arch_pre_main(void *entry, bootinfo_t *bootinfo);
 #endif
 /** @}

 /branches/dynload/kernel/arch/arm32/include/asm.h
 ,15 → 46,14
 {
 }
-/** No I/O port address space on ARM. */
-static inline void outb(ioport_t port, uint8_t v)
+static inline void pio_write_8(ioport_t port, uint8_t v)
 {
+    /* XXX */
 }
-/** No I/O port address space on ARM. */
-static inline uint8_t inb(ioport_t port)
+static inline uint8_t pio_read_8(ioport_t port)
 {
-    return 0;
+    return 0;   /* XXX */
 }
 /** Return base address of current stack.

/branches/dynload/kernel/arch/arm32/include/mm/frame.h
51,6 → 51,7
#define BOOT_PAGE_TABLE_SIZE_IN_FRAMES (BOOT_PAGE_TABLE_SIZE >> FRAME_WIDTH)

extern uintptr_t last_frame;
extern uintptr_t end_frame;

extern void frame_arch_init(void);
extern void boot_page_table_free(void);

 /branches/dynload/kernel/arch/arm32/Makefile.inc
 ,14 → 35,11
 TARGET = arm-linux-gnu
 TOOLCHAIN_DIR = $(CROSS_PREFIX)/arm
-KERNEL_LOAD_ADDRESS = 0x80200000
-DMACHINE = MACHINE_GXEMUL_TESTARM
 ATSIGN = %
 GCC_CFLAGS += -fno-zero-initialized-in-bss
-DEFS += -D__32_BITS__ -DKERNEL_LOAD_ADDRESS=$(KERNEL_LOAD_ADDRESS) -D$(DMACHINE)
+DEFS += -D__32_BITS__
 ARCH_SOURCES = \
     arch/$(KARCH)/src/start.S \

 /branches/dynload/kernel/arch/arm32/src/arm32.c
 ,7 → 34,6
  */
 #include <arch.h>
-#include <arch/boot.h>
 #include <config.h>
 #include <arch/console.h>
 #include <ddi/device.h>
 ,22 → 47,19
 #include <arch/regutils.h>
 #include <arch/machine.h>
 #include <userspace.h>
+#include <macros.h>
-/** Information about loaded tasks. */
-bootinfo_t bootinfo;
 /** Performs arm32 specific initialization before main_bsp() is called. */
-void arch_pre_main(void)
+void arch_pre_main(void *entry __attribute__((unused)), bootinfo_t *bootinfo)
 {
     unsigned int i;
-    init.cnt = bootinfo.cnt;
-    for (i = 0; i < bootinfo.cnt; ++i) {
-        init.tasks[i].addr = bootinfo.tasks[i].addr;
-        init.tasks[i].size = bootinfo.tasks[i].size;
+    init.cnt = bootinfo->cnt;
+    for (i = 0; i < min3(bootinfo->cnt, TASKMAP_MAX_RECORDS, CONFIG_INIT_TASKS); ++i) {
+        init.tasks[i].addr = bootinfo->tasks[i].addr;
+        init.tasks[i].size = bootinfo->tasks[i].size;
     }
 }
 /** Performs arm32 specific initialization before mm is initialized. */

 /branches/dynload/kernel/arch/arm32/src/mm/frame.c
 ,6 → 41,7
 /** Address of the last frame in the memory. */
 uintptr_t last_frame = 0;
+uintptr_t end_frame = 0;
 /** Creates memory zones. */
 void frame_arch_init(void)
 ,7 → 50,8
     zone_create(0, ADDR2PFN(machine_get_memory_size()),
         BOOT_PAGE_TABLE_START_FRAME + BOOT_PAGE_TABLE_SIZE_IN_FRAMES, 0);
     last_frame = machine_get_memory_size();
+    end_frame = last_frame;
     /* blacklist boot page table */
     frame_mark_unavailable(BOOT_PAGE_TABLE_START_FRAME,
         BOOT_PAGE_TABLE_SIZE_IN_FRAMES);

 /branches/dynload/kernel/arch/arm32/src/mm/page.c
 ,5 → 106,11
     return virtaddr;
 }
+void hw_area(uintptr_t *physaddr, pfn_t *frames)
+{
+    *physaddr = end_frame;
+    *frames = ADDR2PFN(0xffffffff - end_frame);
+}
 /** @}
  */

 /branches/dynload/kernel/arch/arm32/src/drivers/gxemul.c
 ,9 → 184,8
 /** Process keyboard interrupt.
  *
  *  @param irq IRQ information.
- *  @param arg Not used.
  */
-static void gxemul_irq_handler(irq_t *irq, void *arg, ...)
+static void gxemul_irq_handler(irq_t *irq)
 {
     if ((irq->notif_cfg.notify) && (irq->notif_cfg.answerbox)) {
         ipc_irq_send_notif(irq);
 ,7 → 203,7
     }
 }
-static irq_ownership_t gxemul_claim(void)
+static irq_ownership_t gxemul_claim(void *instance)
 {
     return IRQ_ACCEPT;
 }
 ,7 → 265,7
     *((uint32_t*) gxemul_hw_map.rtc_freq) = frequency;
 }
-static irq_ownership_t gxemul_timer_claim(void)
+static irq_ownership_t gxemul_timer_claim(void *instance)
 {
     return IRQ_ACCEPT;
 }
 ,7 → 275,7
  * @param irq Interrupt information.
  * @param arg Not used.
  */
-static void gxemul_timer_irq_handler(irq_t *irq, void *arg, ...)
+static void gxemul_timer_irq_handler(irq_t *irq)
 {
     /*
     * We are holding a lock which prevents preemption.
 ,7 → 369,7
             irq_t *irq = irq_dispatch_and_lock(i);
             if (irq) {
                 /* The IRQ handler was found. */
-                irq->handler(irq, irq->arg);
+                irq->handler(irq);
                 spinlock_unlock(&irq->lock);
             } else {
                 /* Spurious interrupt.*/

 /branches/dynload/kernel/arch/arm32/src/start.S
 ,30 → 40,12
     mrs r3, cpsr
     bic r3, r3, #0x1f
     orr r3, r3, #0x13
-    msr cpsr_c, r3
+    msr cpsr_c, r3
     ldr sp, =temp_stack
-    cmp r2, #0
-    beq bootinfo_end
-    ldr r3, =bootinfo
-    bootinfo_loop:
-        ldr r4, [r1]
-        str r4, [r3]
-        add r1, r1, #4
-        add r3, r3, #4
-        add r2, r2, #-4
-        cmp r2, #0
-        bne bootinfo_loop
-    bootinfo_end:
     bl arch_pre_main
     bl main_bsp
     .space TEMP_STACK_SIZE
 ,4 → 56,3
 supervisor_sp:
     .space 4

 /branches/dynload/kernel/arch/ppc32/include/arch.h
 ,7 → 26,7
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup ppc32
+/** @addtogroup ppc32
  * @{
  */
 /** @file
 ,7 → 35,7
 #ifndef KERN_ppc32_ARCH_H_
 #define KERN_ppc32_ARCH_H_
-#include <arch/drivers/cuda.h>
+extern void arch_pre_main(void);
 #endif

 /branches/dynload/kernel/arch/ppc32/include/boot/boot.h
 ,7 → 26,7
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup ppc32
+/** @addtogroup ppc32
  * @{
  */
 /** @file
 ,13 → 35,13
 #ifndef KERN_ppc32_BOOT_H_
 #define KERN_ppc32_BOOT_H_
-#define BOOT_OFFSET     0x8000
+#define BOOT_OFFSET  0x8000
 /* Temporary stack size for boot process */
-#define TEMP_STACK_SIZE 0x1000
+#define TEMP_STACK_SIZE  0x1000
-#define TASKMAP_MAX_RECORDS 32
-#define MEMMAP_MAX_RECORDS 32
+#define TASKMAP_MAX_RECORDS  32
+#define MEMMAP_MAX_RECORDS   32
 #ifndef __ASM__

 /branches/dynload/kernel/arch/ppc32/include/asm.h
 ,15 → 149,14
 extern void userspace_asm(uintptr_t uspace_uarg, uintptr_t stack, uintptr_t entry);
-/** No I/O port address space on PowerPC. */
-static inline void outb(ioport_t port, uint8_t v)
+static inline void pio_write_8(ioport_t port, uint8_t v)
 {
+    /* XXX */
 }
-/** No I/O port address space on PowerPC. */
-static inline uint8_t inb(ioport_t port)
+static inline uint8_t pio_read_8(ioport_t port)
 {
-    return 0;
+    return 0;   /* XXX */
 }
 #endif

 /branches/dynload/kernel/arch/ppc32/include/mm/frame.h
 ,9 → 41,10
 #ifdef KERNEL
 #ifndef __ASM__
-#include <arch/types.h>
+#include <arch/types.h>
 extern uintptr_t last_frame;
+extern uintptr_t end_frame;
 extern void frame_arch_init(void);
 extern void physmem_print(void);

 /branches/dynload/kernel/arch/ppc32/src/boot/boot.S
 ,7 → 33,7
 .global kernel_image_start
 kernel_image_start:
     # load temporal kernel stack
     lis sp, kernel_stack@ha
 ,7 → 52,7
     beq bootinfo_end
     addis r3, r3, 0x8000
     lis r31, bootinfo@ha
     addi r31, r31, bootinfo@l  # r31 = bootinfo

 /branches/dynload/kernel/arch/ppc32/src/ppc32.c
 ,19 → 45,19
 #include <ddi/device.h>
 #include <ddi/irq.h>
 #include <arch/drivers/pic.h>
+#include <macros.h>
-#define IRQ_COUNT   64
+#define IRQ_COUNT  64
 bootinfo_t bootinfo;
 void arch_pre_main(void)
 {
-    /* Setup usermode */
     init.cnt = bootinfo.taskmap.count;
     uint32_t i;
-    for (i = 0; i < bootinfo.taskmap.count; i++) {
+    for (i = 0; i < min3(bootinfo.taskmap.count, TASKMAP_MAX_RECORDS, CONFIG_INIT_TASKS); i++) {
         init.tasks[i].addr = PA2KA(bootinfo.taskmap.tasks[i].addr);
         init.tasks[i].size = bootinfo.taskmap.tasks[i].size;
     }

 /branches/dynload/kernel/arch/ppc32/src/mm/frame.c
 ,6 → 40,7
 #include <print.h>
 uintptr_t last_frame = 0;
+uintptr_t end_frame = 0;
 void physmem_print(void)
 {
 ,7 → 75,9
         if (last_frame < ALIGN_UP(bootinfo.memmap.zones[i].start + bootinfo.memmap.zones[i].size, FRAME_SIZE))
             last_frame = ALIGN_UP(bootinfo.memmap.zones[i].start + bootinfo.memmap.zones[i].size, FRAME_SIZE);
     }
+    end_frame = last_frame;
     /* First is exception vector, second is 'implementation specific',
        third and fourth is reserved, other contain real mode code */
     frame_mark_unavailable(0, 8);

 /branches/dynload/kernel/arch/ppc32/src/mm/page.c
 ,5 → 63,11
     return virtaddr;
 }
+void hw_area(uintptr_t *physaddr, pfn_t *frames)
+{
+    *physaddr = end_frame;
+    *frames = ADDR2PFN(0xffffffff - end_frame);
+}
 /** @}
  */

 /branches/dynload/kernel/arch/ppc32/src/interrupt.c
 ,7 → 73,7
                 ack = true;
             }
-            irq->handler(irq, irq->arg);
+            irq->handler(irq);
             spinlock_unlock(&irq->lock);
         } else {
             /*

 /branches/dynload/kernel/arch/ppc32/src/drivers/cuda.c
 ,7 → 249,7
     return -1;
 }
-static void cuda_irq_handler(irq_t *irq, void *arg, ...)
+static void cuda_irq_handler(irq_t *irq)
 {
     if ((irq->notif_cfg.notify) && (irq->notif_cfg.answerbox))
         ipc_irq_send_notif(irq);
 ,7 → 264,7
     }
 }
-static irq_ownership_t cuda_claim(void)
+static irq_ownership_t cuda_claim(void *instance)
 {
     return IRQ_ACCEPT;
 }

 /branches/dynload/kernel/arch/amd64/include/interrupt.h
 ,7 → 71,6
 /** This is passed to interrupt handlers */
 typedef struct {
     uint64_t rax;
-    uint64_t rbx;
     uint64_t rcx;
     uint64_t rdx;
     uint64_t rsi;
 ,11 → 79,6
     uint64_t r9;
     uint64_t r10;
     uint64_t r11;
-    uint64_t r12;
-    uint64_t r13;
-    uint64_t r14;
-    uint64_t r15;
-    uint64_t rbp;
     uint64_t error_word;
     uint64_t rip;
     uint64_t cs;

 /branches/dynload/kernel/arch/amd64/include/asm.h
 ,7 → 73,7
  * @param port Port to read from
  * @return Value read
  */
-static inline uint8_t inb(uint16_t port)
+static inline uint8_t pio_read_8(uint16_t port)
 {
     uint8_t val;
 ,7 → 88,7
  * @param port Port to write to
  * @param val Value to write
  */
-static inline void outb(uint16_t port, uint8_t val)
+static inline void pio_write_8(uint16_t port, uint8_t val)
 {
     asm volatile ("outb %b0, %w1\n" : : "a" (val), "d" (port));
 }

/branches/dynload/kernel/arch/amd64/include/mm/frame.h
44,6 → 44,7

#ifndef __ASM__
extern uintptr_t last_frame;
extern uintptr_t end_frame;
extern void frame_arch_init(void);
extern void physmem_print(void);
#endif /* __ASM__ */

 /branches/dynload/kernel/arch/amd64/src/asm_utils.S
 ,23 → 26,17
 # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
-#define IREGISTER_SPACE 120
+#define IREGISTER_SPACE 72
-#define IOFFSET_RAX 0x0
-#define IOFFSET_RBX 0x8
-#define IOFFSET_RCX 0x10
-#define IOFFSET_RDX 0x18
-#define IOFFSET_RSI 0x20
-#define IOFFSET_RDI 0x28
-#define IOFFSET_R8 0x30
-#define IOFFSET_R9 0x38
-#define IOFFSET_R10 0x40
-#define IOFFSET_R11 0x48
-#define IOFFSET_R12 0x50
-#define IOFFSET_R13 0x58
-#define IOFFSET_R14 0x60
-#define IOFFSET_R15 0x68
-#define IOFFSET_RBP 0x70
+#define IOFFSET_RAX 0x0
+#define IOFFSET_RCX 0x8
+#define IOFFSET_RDX 0x10
+#define IOFFSET_RSI 0x18
+#define IOFFSET_RDI 0x20
+#define IOFFSET_R8  0x28
+#define IOFFSET_R9  0x30
+#define IOFFSET_R10 0x38
+#define IOFFSET_R11 0x40
 #  Mask for interrupts 0 - 31 (bits 0 - 31) where 0 means that int has no error word
 # and 1 means interrupt with error word
 ,7 → 167,7
     rdmsr
     ret
-# Push all general purpose registers on stack except %rbp, %rsp
+# Push all volatile general purpose registers on stack
 .macro save_all_gpr
     movq %rax, IOFFSET_RAX(%rsp)
     movq %rcx, IOFFSET_RCX(%rsp)
 ,14 → 178,6
     movq %r9, IOFFSET_R9(%rsp)
     movq %r10, IOFFSET_R10(%rsp)
     movq %r11, IOFFSET_R11(%rsp)
-#ifdef CONFIG_DEBUG_ALLREGS
-    movq %rbx, IOFFSET_RBX(%rsp)
-    movq %rbp, IOFFSET_RBP(%rsp)
-    movq %r12, IOFFSET_R12(%rsp)
-    movq %r13, IOFFSET_R13(%rsp)
-    movq %r14, IOFFSET_R14(%rsp)
-    movq %r15, IOFFSET_R15(%rsp)
-#endif
 .endm
 .macro restore_all_gpr
 ,21 → 190,9
     movq IOFFSET_R9(%rsp), %r9
     movq IOFFSET_R10(%rsp), %r10
     movq IOFFSET_R11(%rsp), %r11
-#ifdef CONFIG_DEBUG_ALLREGS
-    movq IOFFSET_RBX(%rsp), %rbx
-    movq IOFFSET_RBP(%rsp), %rbp
-    movq IOFFSET_R12(%rsp), %r12
-    movq IOFFSET_R13(%rsp), %r13
-    movq IOFFSET_R14(%rsp), %r14
-    movq IOFFSET_R15(%rsp), %r15
-#endif
 .endm
-#ifdef CONFIG_DEBUG_ALLREGS
-# define INTERRUPT_ALIGN 256
-#else
-# define INTERRUPT_ALIGN 128
-#endif
+#define INTERRUPT_ALIGN 128
 ## Declare interrupt handlers
 #

 /branches/dynload/kernel/arch/amd64/src/proc/scheduler.c
 ,7 → 39,6
 #include <arch.h>
 #include <arch/context.h>   /* SP_DELTA */
 #include <arch/asm.h>
-#include <arch/debugger.h>
 #include <print.h>
 #include <arch/pm.h>
 #include <arch/ddi/ddi.h>
 ,13 → 67,6
     /* TLS support - set FS to thread local storage */
     write_msr(AMD_MSR_FS, THREAD->arch.tls);
-#ifdef CONFIG_DEBUG_AS_WATCHPOINT
-    /* Set watchpoint on AS to ensure that nobody sets it to zero */
-    if (CPU->id < BKPOINTS_MAX)
-        breakpoint_add(&((the_t *) THREAD->kstack)->as,
-            BKPOINT_WRITE | BKPOINT_CHECK_ZERO, CPU->id);
-#endif
 }
 void after_thread_ran_arch(void)

/branches/dynload/kernel/arch/amd64/src/debugger.c
64,8 → 64,6
.argc = 0,
};

#ifndef CONFIG_DEBUG_AS_WATCHPOINT

static int cmd_del_breakpoint(cmd_arg_t *argv);
static cmd_arg_t del_argv = {
.type = ARG_TYPE_INT
101,7 → 99,6
.argv = &addw_argv
};

#endif /* CONFIG_DEBUG_AS_WATCHPOINT */
#endif /* CONFIG_KCONSOLE */

/* Setup DR register according to table */
320,7 → 317,6
if (!cmd_register(&bkpts_info))
printf("Cannot register command %s\n", bkpts_info.name);

#ifndef CONFIG_DEBUG_AS_WATCHPOINT
cmd_initialize(&delbkpt_info);
if (!cmd_register(&delbkpt_info))
printf("Cannot register command %s\n", delbkpt_info.name);
332,7 → 328,6
cmd_initialize(&addwatchp_info);
if (!cmd_register(&addwatchp_info))
printf("Cannot register command %s\n", addwatchp_info.name);
#endif /* CONFIG_DEBUG_AS_WATCHPOINT */
#endif /* CONFIG_KCONSOLE */

exc_register(VECTOR_DEBUG, "debugger", debug_exception);
378,8 → 373,6
return 1;
}

#ifndef CONFIG_DEBUG_AS_WATCHPOINT

/** Remove breakpoint from table */
int cmd_del_breakpoint(cmd_arg_t *argv)
{
412,7 → 405,6

return 1;
}
#endif /* CONFIG_DEBUG_AS_WATCHPOINT */
#endif /* CONFIG_KCONSOLE */

/** @}

 /branches/dynload/kernel/arch/amd64/src/mm/page.c
 ,5 → 214,11
     return virtaddr;
 }
+void hw_area(uintptr_t *physaddr, pfn_t *frames)
+{
+    *physaddr = end_frame;
+    *frames = ADDR2PFN(0xfffffffffffff - end_frame);
+}
 /** @}
  */

 /branches/dynload/kernel/arch/amd64/src/interrupt.c
 ,12 → 80,6
         istate->rdi, istate->r8);
     printf("%%r9=%#llx, %%r10=%#llx, %%r11=%#llx\n", istate->r9,
         istate->r10, istate->r11);
-#ifdef CONFIG_DEBUG_ALLREGS
-    printf("%%r12=%#llx, %%r13=%#llx, %%r14=%#llx\n", istate->r12,
-        istate->r13, istate->r14);
-    printf("%%r15=%#llx, %%rbx=%#llx, %%rbp=%#llx\n", istate->r15,
-        istate->rbx, &istate->rbp);
-#endif
     printf("%%rsp=%#llx\n", &istate->stack[0]);
 }
 ,7 → 173,7
             trap_virtual_eoi();
             ack = true;
         }
-        irq->handler(irq, irq->arg);
+        irq->handler(irq);
         spinlock_unlock(&irq->lock);
     } else {
         /*

 /branches/dynload/kernel/arch/mips32/_link.ld.in
 ,15 → 1,17
 /*
- *  MIPS32 linker script
- *
+ * MIPS32 linker script
+ *
  *  kernel text
  *  kernel data
- *
+ *
  */
 #undef mips
 #define mips mips
+#define KERNEL_LOAD_ADDRESS 0x80100000
 OUTPUT_ARCH(mips)
 ENTRY(kernel_image_start)
 SECTIONS {
 ,9 → 23,9
     }
     .data : {
         kdata_start = .;
-        *(.data);       /* initialized data */
+        *(.data);                       /* initialized data */
         hardcoded_ktext_size = .;
-        LONG(ktext_end - ktext_start);
+        LONG(ktext_end - ktext_start);
         hardcoded_kdata_size = .;
         LONG(kdata_end - kdata_start);
         hardcoded_load_address = .;
 ,21 → 35,21
         *(.reginfo);
         *(.sbss);
         *(.scommon);
-        *(.bss);        /* uninitialized static variables */
-        *(COMMON);      /* global variables */
+        *(.bss);                        /* uninitialized static variables */
+        *(COMMON);                      /* global variables */
         symbol_table = .;
-        *(symtab.*);
+        *(symtab.*);
     }
     _gp = . + 0x8000;
     .lit8 : { *(.lit8) }
     .lit4 : { *(.lit4) }
     kdata_end = .;
     /DISCARD/ : {
-      *(.mdebug*);
-      *(.pdr);
-      *(.comment);
-      *(.note);
+        *(.mdebug*);
+        *(.pdr);
+        *(.comment);
+        *(.note);
     }
 }

 /branches/dynload/kernel/arch/mips32/include/asm/boot.h
 ,7 → 26,7
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup mips32
+/** @addtogroup mips32
  * @{
  */
 /** @file

 /branches/dynload/kernel/arch/mips32/include/context_offset.h
 ,26 → 76,17
 #define EOFFSET_T5     0x30
 #define EOFFSET_T6     0x34
 #define EOFFSET_T7     0x38
-#define EOFFSET_S0     0x3c
-#define EOFFSET_S1     0x40
-#define EOFFSET_S2     0x44
-#define EOFFSET_S3     0x48
-#define EOFFSET_S4     0x4c
-#define EOFFSET_S5     0x50
-#define EOFFSET_S6     0x54
-#define EOFFSET_S7     0x58
-#define EOFFSET_T8     0x5c
-#define EOFFSET_T9     0x60
-#define EOFFSET_GP     0x64
-#define EOFFSET_SP     0x68
-#define EOFFSET_S8     0x6c
-#define EOFFSET_RA     0x70
-#define EOFFSET_LO     0x74
-#define EOFFSET_HI     0x78
-#define EOFFSET_STATUS 0x7c
-#define EOFFSET_EPC    0x80
-#define EOFFSET_K1     0x84
-#define REGISTER_SPACE 136
+#define EOFFSET_T8     0x3c
+#define EOFFSET_T9     0x40
+#define EOFFSET_GP     0x44
+#define EOFFSET_SP     0x48
+#define EOFFSET_RA     0x4c
+#define EOFFSET_LO     0x50
+#define EOFFSET_HI     0x54
+#define EOFFSET_STATUS 0x58
+#define EOFFSET_EPC    0x5c
+#define EOFFSET_K1     0x60
+#define REGISTER_SPACE 100
 #ifdef __ASM__

 /branches/dynload/kernel/arch/mips32/include/interrupt.h
 ,9 → 38,11
 #include <typedefs.h>
 #include <arch/exception.h>
-#define IVT_ITEMS 32
-#define IVT_FIRST 0
+#define IVT_ITEMS  32
+#define IVT_FIRST  0
+#define VECTOR_TLB_SHOOTDOWN_IPI  EXC_Int
 extern function virtual_timer_fnc;
 extern uint32_t count_hi;

 /branches/dynload/kernel/arch/mips32/include/exception.h
 ,19 → 73,10
     uint32_t t5;
     uint32_t t6;
     uint32_t t7;
-    uint32_t s0;
-    uint32_t s1;
-    uint32_t s2;
-    uint32_t s3;
-    uint32_t s4;
-    uint32_t s5;
-    uint32_t s6;
-    uint32_t s7;
     uint32_t t8;
     uint32_t t9;
     uint32_t gp;
     uint32_t sp;
-    uint32_t s8;
     uint32_t ra;
     uint32_t lo;

 /branches/dynload/kernel/arch/mips32/include/smp/dorder.h
 ,0 → 1,34
+/*
+ * Copyright (c) 2007 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef KERN_mips32_DORDER_H_
+#define KERN_mips32_DORDER_H_
+extern void ipi_broadcast_arch(int ipi);
+#endif

 /branches/dynload/kernel/arch/mips32/include/atomic.h
 ,14 → 35,14
 #ifndef KERN_mips32_ATOMIC_H_
 #define KERN_mips32_ATOMIC_H_
-#define atomic_inc(x)   ((void) atomic_add(x, 1))
-#define atomic_dec(x)   ((void) atomic_add(x, -1))
+#define atomic_inc(x)  ((void) atomic_add(x, 1))
+#define atomic_dec(x)  ((void) atomic_add(x, -1))
-#define atomic_postinc(x) (atomic_add(x, 1) - 1)
-#define atomic_postdec(x) (atomic_add(x, -1) + 1)
+#define atomic_postinc(x)  (atomic_add(x, 1) - 1)
+#define atomic_postdec(x)  (atomic_add(x, -1) + 1)
-#define atomic_preinc(x) atomic_add(x, 1)
-#define atomic_predec(x) atomic_add(x, -1)
+#define atomic_preinc(x)  atomic_add(x, 1)
+#define atomic_predec(x)  atomic_add(x, -1)
 /* Atomic addition of immediate value.
  *
 ,19 → 54,37
 static inline long atomic_add(atomic_t *val, int i)
 {
     long tmp, v;
     asm volatile (
         "1:\n"
         "   ll %0, %1\n"
-        "   addu %0, %0, %3\n"  /* same as addi, but never traps on overflow */
-        "       move %2, %0\n"
+        "   addu %0, %0, %3\n"  /* same as addi, but never traps on overflow */
+        "   move %2, %0\n"
         "   sc %0, %1\n"
-        "   beq %0, %4, 1b\n"   /* if the atomic operation failed, try again */
+        "   beq %0, %4, 1b\n"   /* if the atomic operation failed, try again */
         "   nop\n"
         : "=&r" (tmp), "+m" (val->count), "=&r" (v)
         : "r" (i), "i" (0)
-        );
+    );
+    return v;
+}
+static inline uint32_t test_and_set(atomic_t *val) {
+    uint32_t tmp, v;
+    asm volatile (
+        "1:\n"
+        "   ll %2, %1\n"
+        "   bnez %2, 2f\n"
+        "   li %0, %3\n"
+        "   sc %0, %1\n"
+        "   beqz %0, 1b\n"
+        "2:\n"
+        : "=&r" (tmp), "+m" (val->count), "=&r" (v)
+        : "i" (1)
+    );
     return v;
 }

 /branches/dynload/kernel/arch/mips32/include/arch.h
 ,7 → 26,7
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup mips32
+/** @addtogroup mips32
  * @{
  */
 /** @file
 ,6 → 35,26
 #ifndef KERN_mips32_ARCH_H_
 #define KERN_mips32_ARCH_H_
+#define TASKMAP_MAX_RECORDS  32
+#define CPUMAP_MAX_RECORDS   32
+#include <typedefs.h>
+extern count_t cpu_count;
+typedef struct {
+    uintptr_t addr;
+    uint32_t size;
+} utask_t;
+typedef struct {
+    uint32_t cpumap;
+    uint32_t cnt;
+    utask_t tasks[TASKMAP_MAX_RECORDS];
+} bootinfo_t;
+extern void arch_pre_main(void *entry, bootinfo_t *bootinfo);
 #endif
 /** @}

 /branches/dynload/kernel/arch/mips32/include/asm.h
 ,7 → 55,11
 {
     uintptr_t v;
-    asm volatile ("and %0, $29, %1\n" : "=r" (v) : "r" (~(STACK_SIZE-1)));
+    asm volatile (
+        "and %0, $29, %1\n"
+        : "=r" (v)
+        : "r" (~(STACK_SIZE-1))
+    );
     return v;
 }
 ,22 → 67,22
 extern void cpu_halt(void);
 extern void asm_delay_loop(uint32_t t);
 extern void userspace_asm(uintptr_t ustack, uintptr_t uspace_uarg,
-              uintptr_t entry);
+    uintptr_t entry);
 extern ipl_t interrupts_disable(void);
 extern ipl_t interrupts_enable(void);
 extern void interrupts_restore(ipl_t ipl);
 extern ipl_t interrupts_read(void);
+extern void asm_delay_loop(uint32_t t);
-/** No I/O port address space on MIPS. */
-static inline void outb(ioport_t port, uint8_t v)
+static inline void pio_write_8(ioport_t port, uint8_t v)
 {
+    /* XXX */
 }
-/** No I/O port address space on MIPS. */
-static inline uint8_t inb(ioport_t port)
+static inline uint8_t pio_read_8(ioport_t port)
 {
-    return 0;
+    return 0;   /* XXX */
 }
 #endif

 /branches/dynload/kernel/arch/mips32/include/mm/frame.h
 ,15 → 35,19
 #ifndef KERN_mips32_FRAME_H_
 #define KERN_mips32_FRAME_H_
-#define FRAME_WIDTH     14  /* 16K */
-#define FRAME_SIZE      (1 << FRAME_WIDTH)
+#define FRAME_WIDTH  14  /* 16K */
+#define FRAME_SIZE   (1 << FRAME_WIDTH)
 #ifdef KERNEL
 #ifndef __ASM__
+#include <typedefs.h>
 extern void frame_arch_init(void);
 extern void physmem_print(void);
+extern uintptr_t end_frame;
 #endif /* __ASM__ */
 #endif /* KERNEL */

 /branches/dynload/kernel/arch/mips32/include/cpu.h
 ,7 → 42,7
     uint32_t imp_num;
     uint32_t rev_num;
 } cpu_arch_t;
 #endif
 /** @}

 /branches/dynload/kernel/arch/mips32/Makefile.inc
 ,11 → 33,9
 TARGET = mipsel-linux-gnu
 TOOLCHAIN_DIR = $(CROSS_PREFIX)/mipsel
-KERNEL_LOAD_ADDRESS = 0x80100000
 GCC_CFLAGS += -mno-abicalls -G 0 -fno-zero-initialized-in-bss
-DEFS += -D__32_BITS__ -D$(MACHINE) -DKERNEL_LOAD_ADDRESS=$(KERNEL_LOAD_ADDRESS)
+DEFS += -D__32_BITS__
 ## Accepted MACHINEs
 #
 ,7 → 72,6
     arch/$(KARCH)/src/context.S \
     arch/$(KARCH)/src/panic.S \
     arch/$(KARCH)/src/mips32.c \
-    arch/$(KARCH)/src/dummy.S \
     arch/$(KARCH)/src/console.c \
     arch/$(KARCH)/src/asm.S \
     arch/$(KARCH)/src/exception.c \
 ,4 → 87,5
     arch/$(KARCH)/src/ddi/ddi.c \
     arch/$(KARCH)/src/drivers/msim.c \
     arch/$(KARCH)/src/drivers/serial.c \
-    arch/$(KARCH)/src/smp/order.c
+    arch/$(KARCH)/src/smp/dorder.c \
+    arch/$(KARCH)/src/smp/smp.c

 /branches/dynload/kernel/arch/mips32/src/exception.c
 ,7 → 144,7
     int i;
     /* decode interrupt number and process the interrupt */
-    cause = (cp0_cause_read() >> 8) &0xff;
+    cause = (cp0_cause_read() >> 8) & 0xff;
     for (i = 0; i < 8; i++) {
         if (cause & (1 << i)) {
 ,7 → 153,7
                 /*
                  * The IRQ handler was found.
                  */
-                irq->handler(irq, irq->arg);
+                irq->handler(irq);
                 spinlock_unlock(&irq->lock);
             } else {
                 /*
 ,7 → 160,8
                  * Spurious interrupt.
                  */
 #ifdef CONFIG_DEBUG
-                printf("cpu%u: spurious interrupt (inum=%d)\n", CPU->id, i);
+                printf("cpu%u: spurious interrupt (inum=%d)\n",
+                    CPU->id, i);
 #endif
             }
         }

 /branches/dynload/kernel/arch/mips32/src/asm.S
 ,7 → 27,7
 #
 #include <arch/asm/regname.h>
 .text
 .macro cp0_read reg
 ,6 → 46,11
 .set noreorder
 .set nomacro
+.global asm_delay_loop
+asm_delay_loop:
+    j $31
+    nop
 .global cpu_halt
 cpu_halt:
     j cpu_halt

 /branches/dynload/kernel/arch/mips32/src/start.S
 ,7 → 31,7
 #include <arch/asm/boot.h>
 #include <arch/context_offset.h>
 #include <arch/stack.h>
 .text
 .set noat
 ,18 → 75,6
     mfhi $at
     sw $at, EOFFSET_HI(\r)
-#ifdef CONFIG_DEBUG_ALLREGS
-    sw $s0, EOFFSET_S0(\r)
-    sw $s1, EOFFSET_S1(\r)
-    sw $s2, EOFFSET_S2(\r)
-    sw $s3, EOFFSET_S3(\r)
-    sw $s4, EOFFSET_S4(\r)
-    sw $s5, EOFFSET_S5(\r)
-    sw $s6, EOFFSET_S6(\r)
-    sw $s7, EOFFSET_S7(\r)
-    sw $s8, EOFFSET_S8(\r)
-#endif
     sw $gp, EOFFSET_GP(\r)
     sw $ra, EOFFSET_RA(\r)
     sw $k1, EOFFSET_K1(\r)
 ,17 → 120,6
     lw $t8, EOFFSET_T8(\r)
     lw $t9, EOFFSET_T9(\r)
-#ifdef CONFIG_DEBUG_ALLREGS
-    lw $s0, EOFFSET_S0(\r)
-    lw $s1, EOFFSET_S1(\r)
-    lw $s2, EOFFSET_S2(\r)
-    lw $s3, EOFFSET_S3(\r)
-    lw $s4, EOFFSET_S4(\r)
-    lw $s5, EOFFSET_S5(\r)
-    lw $s6, EOFFSET_S6(\r)
-    lw $s7, EOFFSET_S7(\r)
-    lw $s8, EOFFSET_S8(\r)
-#endif
     lw $gp, EOFFSET_GP(\r)
     lw $ra, EOFFSET_RA(\r)
     lw $k1, EOFFSET_K1(\r)
 ,9 → 152,9
     ori $k0, $k0, %lo(supervisor_sp)
     # Move $k0 (superveisor_sp)
     lw $k0, 0($k0)
-:
+:
 .endm
 .org 0x0
 kernel_image_start:
     /* Load temporary stack */
 ,31 → 161,12
     lui $sp, %hi(end_stack)
     ori $sp, $sp, %lo(end_stack)
-    /* $a1 contains physical address of bootinfo_t */
-    /* $a2 contains size of bootinfo_t */
-    beq $a2, $0, bootinfo_end
-    /* Not sure about this, but might be needed for PIC code???? */
+    /* Not sure about this, but might
+       be needed for PIC code */
     lui $gp, 0x8000
-    lui $a3, %hi(bootinfo)
-    ori $a3, $a3, %lo(bootinfo)
+    /* $a1 contains physical address of bootinfo_t */
-    bootinfo_loop:
-        lw $v0, 0($a1)
-        sw $v0, 0($a3)
-        addi $a1, $a1, 4
-        addi $a3, $a3, 4
-        addi $a2, $a2, -4
-        bgtz $a2, bootinfo_loop
-        nop
-    bootinfo_end:
     jal arch_pre_main
     nop
 ,8 → 186,8
 exception_entry:
     j exception_handler
-    nop
+    nop
 exception_handler:
     KERNEL_STACK_TO_K0
     sub $k0, REGISTER_SPACE
 ,17 → 196,17
     mfc0 $k0, $cause
-    sra $k0, $k0, 0x2       # cp0_exc_cause() part 1
-    andi $k0, $k0, 0x1f     # cp0_exc_cause() part 2
-    sub $k0, 8          # 8 = SYSCALL
+    sra $k0, $k0, 0x2    # cp0_exc_cause() part 1
+    andi $k0, $k0, 0x1f  # cp0_exc_cause() part 2
+    sub $k0, 8           # 8 = SYSCALL
     beqz $k0, syscall_shortcut
-    add $k0, 8          # Revert $k0 back to correct exc number
+    add $k0, 8           # Revert $k0 back to correct exc number
     REGISTERS_STORE_AND_EXC_RESET $sp
     move $a1, $sp
-    jal exc_dispatch        # exc_dispatch(excno, register_space)
+    jal exc_dispatch     # exc_dispatch(excno, register_space)
     move $a0, $k0
     REGISTERS_LOAD $sp

 /branches/dynload/kernel/arch/mips32/src/mips32.c
 ,7 → 33,6
  */
 #include <arch.h>
-#include <arch/boot.h>
 #include <arch/cp0.h>
 #include <arch/exception.h>
 #include <mm/as.h>
 ,34 → 57,39
 #include <arch/asm/regname.h>
-/* Size of the code jumping to the exception handler code
- * - J+NOP
+/* Size of the code jumping to the exception handler code
+ * - J+NOP
  */
-#define EXCEPTION_JUMP_SIZE    8
+#define EXCEPTION_JUMP_SIZE  8
-#define TLB_EXC ((char *) 0x80000000)
-#define NORM_EXC ((char *) 0x80000180)
-#define CACHE_EXC ((char *) 0x80000100)
+#define TLB_EXC    ((char *) 0x80000000)
+#define NORM_EXC   ((char *) 0x80000180)
+#define CACHE_EXC  ((char *) 0x80000100)
 /* Why the linker moves the variable 64K away in assembler
- * when not in .text section ????????
+ * when not in .text section?
  */
+/* Stack pointer saved when entering user mode */
 uintptr_t supervisor_sp __attribute__ ((section (".text")));
-/* Stack pointer saved when entering user mode */
-/* TODO: How do we do it on SMP system???? */
-bootinfo_t bootinfo __attribute__ ((section (".text")));
-void arch_pre_main(void)
+count_t cpu_count = 0;
+void arch_pre_main(void *entry __attribute__((unused)), bootinfo_t *bootinfo)
 {
     /* Setup usermode */
-    init.cnt = bootinfo.cnt;
+    init.cnt = bootinfo->cnt;
-    uint32_t i;
+    count_t i;
+    for (i = 0; i < min3(bootinfo->cnt, TASKMAP_MAX_RECORDS, CONFIG_INIT_TASKS); i++) {
+        init.tasks[i].addr = bootinfo->tasks[i].addr;
+        init.tasks[i].size = bootinfo->tasks[i].size;
+    }
-    for (i = 0; i < bootinfo.cnt; i++) {
-        init.tasks[i].addr = bootinfo.tasks[i].addr;
-        init.tasks[i].size = bootinfo.tasks[i].size;
+    for (i = 0; i < CPUMAP_MAX_RECORDS; i++) {
+        if ((bootinfo->cpumap & (1 << i)) != 0)
+            cpu_count++;
     }
 }
 ,19 → 141,19
     fb_init(&gxemul_prop);
 #endif
-#ifdef msim
+#ifdef MACHINE_msim
     sysinfo_set_item_val("machine.msim", NULL, 1);
 #endif
-#ifdef simics
+#ifdef MACHINE_simics
     sysinfo_set_item_val("machine.simics", NULL, 1);
 #endif
-#ifdef bgxemul
+#ifdef MACHINE_bgxemul
     sysinfo_set_item_val("machine.bgxemul", NULL, 1);
 #endif
-#ifdef lgxemul
+#ifdef MACHINE_lgxemul
     sysinfo_set_item_val("machine.lgxemul", NULL, 1);
 #endif
 }
 ,6 → 170,10
 {
 }
+void calibrate_delay_loop(void)
+{
+}
 void userspace(uspace_arg_t *kernel_uarg)
 {
     /* EXL = 1, UM = 1, IE = 1 */

 /branches/dynload/kernel/arch/mips32/src/smp/dorder.c
 ,0 → 1,47
+/*
+ * Copyright (c) 2007 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup mips32
+ * @{
+ */
+/** @file
+ */
+#include <arch/smp/dorder.h>
+#define MSIM_DORDER_ADDRESS  0xB0000004
+void ipi_broadcast_arch(int ipi)
+{
+#ifdef CONFIG_SMP
+    *((volatile unsigned int *) MSIM_DORDER_ADDRESS) = 0x7FFFFFFF;
+#endif
+}
+/** @}
+ */

 /branches/dynload/kernel/arch/mips32/src/smp/smp.c
 ,0 → 1,53
+/*
+ * Copyright (c) 2009 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup mips32
+ * @{
+ */
+/** @file
+ */
+#include <config.h>
+#include <smp/smp.h>
+#include <arch/arch.h>
+#ifdef CONFIG_SMP
+void smp_init(void)
+{
+    config.cpu_count = cpu_count;
+}
+void kmp(void *arg __attribute__((unused)))
+{
+}
+#endif /* CONFIG_SMP */
+/** @}
+ */

 /branches/dynload/kernel/arch/mips32/src/debugger.c
 ,7 → 162,7
     for (i = 0; i < BKPOINTS_MAX; i++) {
         if (breakpoints[i].address == (uintptr_t)argv->intval) {
             printf("Duplicate breakpoint %d.\n", i);
-            spinlock_unlock(&bkpoints_lock);
+            spinlock_unlock(&bkpoint_lock);
             return 0;
         } else if (breakpoints[i].address == (uintptr_t)argv->intval +
             sizeof(unative_t) || breakpoints[i].address ==
 ,10 → 169,10
             (uintptr_t)argv->intval - sizeof(unative_t)) {
             printf("Adjacent breakpoints not supported, conflict "
                 "with %d.\n", i);
-            spinlock_unlock(&bkpoints_lock);
+            spinlock_unlock(&bkpoint_lock);
             return 0;
         }
     }
     for (i = 0; i < BKPOINTS_MAX; i++)

 /branches/dynload/kernel/arch/mips32/src/mm/tlb.c
 ,7 → 26,7
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup mips32mm
+/** @addtogroup mips32mm
  * @{
  */
 /** @file
 ,7 → 41,7
 #include <panic.h>
 #include <arch.h>
 #include <symtab.h>
-#include <synch/spinlock.h>
+#include <synch/mutex.h>
 #include <print.h>
 #include <debug.h>
 #include <align.h>
 ,15 → 92,15
     uintptr_t badvaddr;
     pte_t *pte;
     int pfrc;
     badvaddr = cp0_badvaddr_read();
-    spinlock_lock(&AS->lock);
+    mutex_lock(&AS->lock);
     asid = AS->asid;
-    spinlock_unlock(&AS->lock);
+    mutex_unlock(&AS->lock);
     page_table_lock(AS, true);
     pte = find_mapping_and_check(badvaddr, PF_ACCESS_READ, istate, &pfrc);
     if (!pte) {
         switch (pfrc) {

 /branches/dynload/kernel/arch/mips32/src/mm/frame.c
 ,7 → 65,9
 static count_t phys_regions_count = 0;
 static phys_region_t phys_regions[MAX_REGIONS];
+uintptr_t end_frame = 0;
 /** Check whether frame is available
  *
  * Returns true if given frame is generally available for use.
 ,7 → 77,7
  */
 static bool frame_available(pfn_t frame)
 {
-#ifdef msim
+#ifdef MACHINE_msim
     /* MSIM device (dprinter) */
     if (frame == (KA2PA(MSIM_VIDEORAM) >> ZERO_PAGE_WIDTH))
         return false;
 ,13 → 87,13
         return false;
 #endif
-#ifdef simics
+#ifdef MACHINE_simics
     /* Simics device (serial line) */
     if (frame == (KA2PA(SERIAL_ADDRESS) >> ZERO_PAGE_WIDTH))
         return false;
 #endif
-#if defined(lgxemul) || defined(bgxemul)
+#if defined(MACHINE_lgxemul) || defined(MACHINE_bgxemul)
     /* gxemul devices */
     if (overlaps(frame << ZERO_PAGE_WIDTH, ZERO_PAGE_SIZE,
 x10000000, MB2SIZE(256)))
 ,8 → 238,10
         }
     }
-    frame_add_region(start_frame, frame);
+    end_frame = frame;
+    frame_add_region(start_frame, end_frame);
     /* Blacklist interrupt vector frame */
     frame_mark_unavailable(0, 1);

 /branches/dynload/kernel/arch/mips32/src/mm/page.c
 ,7 → 26,7
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup mips32mm
+/** @addtogroup mips32mm
  * @{
  */
 /** @file
 ,6 → 35,7
 #include <arch/mm/page.h>
 #include <genarch/mm/page_pt.h>
 #include <mm/page.h>
+#include <mm/frame.h>
 void page_arch_init(void)
 {
 ,5 → 51,11
     return physaddr + 0xa0000000;
 }
+void hw_area(uintptr_t *physaddr, pfn_t *frames)
+{
+    *physaddr = end_frame;
+    *frames = ADDR2PFN(0xffffffff - end_frame);
+}
 /** @}
  */

 /branches/dynload/kernel/arch/mips32/src/interrupt.c
 ,8 → 41,9
 #include <ipc/sysipc.h>
 #include <ddi/device.h>
-#define IRQ_COUNT 8
-#define TIMER_IRQ 7
+#define IRQ_COUNT   8
+#define TIMER_IRQ   7
+#define DORDER_IRQ  5
 function virtual_timer_fnc = NULL;
 static irq_t timer_irq;
 ,12 → 101,12
     cp0_compare_write(nextcount);
 }
-static irq_ownership_t timer_claim(void)
+static irq_ownership_t timer_claim(void *instance)
 {
     return IRQ_ACCEPT;
 }
-static void timer_irq_handler(irq_t *irq, void *arg, ...)
+static void timer_irq_handler(irq_t *irq)
 {
     unsigned long drift;

 /branches/dynload/kernel/arch/mips32/src/drivers/serial.c
 ,7 → 112,7
 }
 /** Process keyboard interrupt. Does not work in simics? */
-static void serial_irq_handler(irq_t *irq, void *arg, ...)
+static void serial_irq_handler(irq_t *irq)
 {
     if ((irq->notif_cfg.notify) && (irq->notif_cfg.answerbox))
         ipc_irq_send_notif(irq);
 ,7 → 120,7
         serial_handler();
 }
-static irq_ownership_t serial_claim(void)
+static irq_ownership_t serial_claim(void *instance)
 {
     return IRQ_ACCEPT;
 }

 /branches/dynload/kernel/arch/mips32/src/drivers/msim.c
 ,7 → 41,6
 #include <sysinfo/sysinfo.h>
 #include <ddi/ddi.h>
-static parea_t msim_parea;
 static chardev_t console;
 static irq_t msim_irq;
 ,7 → 93,7
 }
 /** Process keyboard interrupt. */
-static void msim_irq_handler(irq_t *irq, void *arg, ...)
+static void msim_irq_handler(irq_t *irq)
 {
     if ((irq->notif_cfg.notify) && (irq->notif_cfg.answerbox))
         ipc_irq_send_notif(irq);
 ,7 → 109,7
     }
 }
-static irq_ownership_t msim_claim(void)
+static irq_ownership_t msim_claim(void *instance)
 {
     return IRQ_ACCEPT;
 }
 ,12 → 155,6
     sysinfo_set_item_val("kbd.inr", NULL, MSIM_KBD_IRQ);
     sysinfo_set_item_val("kbd.address.virtual", NULL, MSIM_KBD_ADDRESS);
-    msim_parea.pbase = KA2PA(MSIM_VIDEORAM);
-    msim_parea.vbase = MSIM_VIDEORAM;
-    msim_parea.frames = 1;
-    msim_parea.cacheable = false;
-    ddi_parea_register(&msim_parea);
     sysinfo_set_item_val("fb", NULL, true);
     sysinfo_set_item_val("fb.kind", NULL, 3);
     sysinfo_set_item_val("fb.address.physical", NULL, KA2PA(MSIM_VIDEORAM));

 /branches/dynload/kernel/arch/ia32/include/interrupt.h
 ,10 → 72,6
     uint32_t eax;
     uint32_t ecx;
     uint32_t edx;
-    uint32_t esi;
-    uint32_t edi;
-    uint32_t ebp;
-    uint32_t ebx;
     uint32_t gs;
     uint32_t fs;

 /branches/dynload/kernel/arch/ia32/include/asm.h
 ,7 → 105,7
  * @param port Port to write to
  * @param val Value to write
  */
-static inline void outb(uint16_t port, uint8_t val)
+static inline void pio_write_8(uint16_t port, uint8_t val)
 {
     asm volatile ("outb %b0, %w1\n" : : "a" (val), "d" (port) );
 }
 ,7 → 117,7
  * @param port Port to write to
  * @param val Value to write
  */
-static inline void outw(uint16_t port, uint16_t val)
+static inline void pio_write_16(uint16_t port, uint16_t val)
 {
     asm volatile ("outw %w0, %w1\n" : : "a" (val), "d" (port) );
 }
 ,7 → 129,7
  * @param port Port to write to
  * @param val Value to write
  */
-static inline void outl(uint16_t port, uint32_t val)
+static inline void pio_write_32(uint16_t port, uint32_t val)
 {
     asm volatile ("outl %l0, %w1\n" : : "a" (val), "d" (port) );
 }
 ,7 → 141,7
  * @param port Port to read from
  * @return Value read
  */
-static inline uint8_t inb(uint16_t port)
+static inline uint8_t pio_read_8(uint16_t port)
 {
     uint8_t val;
 ,7 → 156,7
  * @param port Port to read from
  * @return Value read
  */
-static inline uint16_t inw(uint16_t port)
+static inline uint16_t pio_read_16(uint16_t port)
 {
     uint16_t val;
 ,7 → 171,7
  * @param port Port to read from
  * @return Value read
  */
-static inline uint32_t inl(uint16_t port)
+static inline uint32_t pio_read_32(uint16_t port)
 {
     uint32_t val;

/branches/dynload/kernel/arch/ia32/include/mm/frame.h
44,6 → 44,7
#include <arch/types.h>

extern uintptr_t last_frame;
extern uintptr_t end_frame;

extern void frame_arch_init(void);
extern void physmem_print(void);

 /branches/dynload/kernel/arch/ia32/include/barrier.h
 ,7 → 69,7
 #endif
 }
-#ifdef CONFIG_FENCES_P4
+#if defined(CONFIG_FENCES_P4)
 #   define memory_barrier()     asm volatile ("mfence\n" ::: "memory")
 #   define read_barrier()       asm volatile ("lfence\n" ::: "memory")
 #   ifdef CONFIG_WEAK_MEMORY
 ,7 → 77,7
 #   else
 #       define write_barrier()  asm volatile( "" ::: "memory");
 #   endif
-#elif CONFIG_FENCES_P3
+#elif defined(CONFIG_FENCES_P3)
 #   define memory_barrier()     cpuid_serialization()
 #   define read_barrier()       cpuid_serialization()
 #   ifdef CONFIG_WEAK_MEMORY

 /branches/dynload/kernel/arch/ia32/include/drivers/i8042.h
 ,22 → 47,22
 static inline void i8042_data_write(uint8_t data)
 {
-    outb(i8042_DATA, data);
+    pio_write_8(i8042_DATA, data);
 }
 static inline uint8_t i8042_data_read(void)
 {
-    return inb(i8042_DATA);
+    return pio_read_8(i8042_DATA);
 }
 static inline uint8_t i8042_status_read(void)
 {
-    return inb(i8042_STATUS);
+    return pio_read_8(i8042_STATUS);
 }
 static inline void i8042_command_write(uint8_t command)
 {
-    outb(i8042_STATUS, command);
+    pio_write_8(i8042_STATUS, command);
 }
 #endif

 /branches/dynload/kernel/arch/ia32/src/asm.S
 ,14 → 268,6
     pushl %fs
     pushl %gs
-#ifdef CONFIG_DEBUG_ALLREGS
-    pushl %ebx
-    pushl %ebp
-    pushl %edi
-    pushl %esi
-#else
-    subl $16, %esp
-#endif
     pushl %edx
     pushl %ecx
     pushl %eax
 ,14 → 289,6
     popl %eax
     popl %ecx
     popl %edx
-#ifdef CONFIG_DEBUG_ALLREGS
-    popl %esi
-    popl %edi
-    popl %ebp
-    popl %ebx
-#else
-    addl $16, %esp
-#endif
     popl %gs
     popl %fs

 /branches/dynload/kernel/arch/ia32/src/smp/smp.c
 ,8 → 122,8
      * Save 0xa to address 0xf of the CMOS RAM.
      * BIOS will not do the POST after the INIT signal.
      */
-    outb(0x70, 0xf);
-    outb(0x71, 0xa);
+    pio_write_8(0x70, 0xf);
+    pio_write_8(0x71, 0xa);
     pic_disable_irqs(0xffff);
     apic_init();

 /branches/dynload/kernel/arch/ia32/src/smp/apic.c
 ,12 → 132,12
 #endif
 }
-static irq_ownership_t l_apic_timer_claim(void)
+static irq_ownership_t l_apic_timer_claim(void *instance)
 {
     return IRQ_ACCEPT;
 }
-static void l_apic_timer_irq_handler(irq_t *irq, void *arg __attribute__((unused)), ...)
+static void l_apic_timer_irq_handler(irq_t *irq)
 {
     /*
      * Holding a spinlock could prevent clock() from preempting

 /branches/dynload/kernel/arch/ia32/src/proc/scheduler.c
 ,7 → 38,6
 #include <proc/thread.h>
 #include <arch.h>
 #include <arch/context.h>   /* SP_DELTA */
-#include <arch/debugger.h>
 #include <arch/pm.h>
 #include <arch/asm.h>
 #include <arch/ddi/ddi.h>
 ,15 → 69,6
     /* Set up TLS in GS register */
     set_tls_desc(THREAD->arch.tls);
-#ifdef CONFIG_DEBUG_AS_WATCHPOINT
-    /* Set watchpoint on AS to ensure that nobody sets it to zero */
-    if (CPU->id < BKPOINTS_MAX) {
-        the_t *the = THE;
-        breakpoint_add(&((the_t *) the->thread->kstack)->as,
-            BKPOINT_WRITE | BKPOINT_CHECK_ZERO, the->cpu->id);
-    }
-#endif
 }
 void after_thread_ran_arch(void)

 /branches/dynload/kernel/arch/ia32/src/mm/frame.c
 ,6 → 50,7
 size_t hardcoded_unmapped_kdata_size = 0;
 uintptr_t last_frame = 0;
+uintptr_t end_frame = 0;
 static void init_e820_memory(pfn_t minconf)
 {
 ,8 → 74,10
                 e820table[i].size, FRAME_SIZE))
                 last_frame =
                     ALIGN_UP(e820table[i].base_address + e820table[i].size, FRAME_SIZE);
-        }
+        }
     }
+    end_frame = last_frame;
 }
 static char *e820names[] = {
 ,16 → 116,14
     if (config.cpu_active == 1) {
         minconf = 1;
 #ifdef CONFIG_SMP
         minconf = max(minconf,
             ADDR2PFN(AP_BOOT_OFFSET + hardcoded_unmapped_ktext_size +
             hardcoded_unmapped_kdata_size));
 #endif
-#ifdef CONFIG_SIMICS_FIX
-        minconf = max(minconf, ADDR2PFN(0x10000));
-#endif
         init_e820_memory(minconf);
         /* Reserve frame 0 (BIOS data) */
         frame_mark_unavailable(0, 1);
 ,12 → 132,7
         frame_mark_unavailable(AP_BOOT_OFFSET >> FRAME_WIDTH,
             (hardcoded_unmapped_ktext_size +
             hardcoded_unmapped_kdata_size) >> FRAME_WIDTH);
-#ifdef CONFIG_SIMICS_FIX
-        /* Don't know why, but these addresses help */
-        frame_mark_unavailable(0xd000 >> FRAME_WIDTH, 3);
 #endif
-#endif
     }
 }

 /branches/dynload/kernel/arch/ia32/src/mm/page.c
 ,6 → 93,12
     return virtaddr;
 }
+void hw_area(uintptr_t *physaddr, pfn_t *frames)
+{
+    *physaddr = end_frame;
+    *frames = ADDR2PFN(0xffffffff - end_frame);
+}
 void page_fault(int n __attribute__((unused)), istate_t *istate)
 {
     uintptr_t page;
 ,7 → 108,7
     if (istate->error_word & PFERR_CODE_RSVD)
         panic("Reserved bit set in page directory.");
     if (istate->error_word & PFERR_CODE_RW)
         access = PF_ACCESS_WRITE;
     else

 /branches/dynload/kernel/arch/ia32/src/interrupt.c
 ,9 → 77,6
     printf("ERROR_WORD=%#lx\n", istate->error_word);
     printf("%%cs=%#lx,flags=%#lx\n", istate->cs, istate->eflags);
     printf("%%eax=%#lx, %%ecx=%#lx, %%edx=%#lx, %%esp=%p\n", istate->eax, istate->ecx, istate->edx, &istate->stack[0]);
-#ifdef CONFIG_DEBUG_ALLREGS
-    printf("%%esi=%#lx, %%edi=%#lx, %%ebp=%#lx, %%ebx=%#lx\n", istate->esi, istate->edi, istate->ebp, istate->ebx);
-#endif
     printf("stack: %#lx, %#lx, %#lx, %#lx\n", istate->stack[0], istate->stack[1], istate->stack[2], istate->stack[3]);
     printf("       %#lx, %#lx, %#lx, %#lx\n", istate->stack[4], istate->stack[5], istate->stack[6], istate->stack[7]);
 }
 ,7 → 188,7
             trap_virtual_eoi();
             ack = true;
         }
-        irq->handler(irq, irq->arg);
+        irq->handler(irq);
         spinlock_unlock(&irq->lock);
     } else {
         /*

 /branches/dynload/kernel/arch/ia32/src/drivers/i8259.c
 ,28 → 49,28
 void i8259_init(void)
 {
     /* ICW1: this is ICW1, ICW4 to follow */
-    outb(PIC_PIC0PORT1, PIC_ICW1 | PIC_NEEDICW4);
+    pio_write_8(PIC_PIC0PORT1, PIC_ICW1 | PIC_NEEDICW4);
     /* ICW2: IRQ 0 maps to INT IRQBASE */
-    outb(PIC_PIC0PORT2, IVT_IRQBASE);
+    pio_write_8(PIC_PIC0PORT2, IVT_IRQBASE);
     /* ICW3: pic1 using IRQ IRQ_PIC1 */
-    outb(PIC_PIC0PORT2, 1 << IRQ_PIC1);
+    pio_write_8(PIC_PIC0PORT2, 1 << IRQ_PIC1);
     /* ICW4: i8086 mode */
-    outb(PIC_PIC0PORT2, 1);
+    pio_write_8(PIC_PIC0PORT2, 1);
     /* ICW1: ICW1, ICW4 to follow */
-    outb(PIC_PIC1PORT1, PIC_ICW1 | PIC_NEEDICW4);
+    pio_write_8(PIC_PIC1PORT1, PIC_ICW1 | PIC_NEEDICW4);
     /* ICW2: IRQ 8 maps to INT (IVT_IRQBASE + 8) */
-    outb(PIC_PIC1PORT2, IVT_IRQBASE + 8);
+    pio_write_8(PIC_PIC1PORT2, IVT_IRQBASE + 8);
     /* ICW3: pic1 is known as IRQ_PIC1 */
-    outb(PIC_PIC1PORT2, IRQ_PIC1);
+    pio_write_8(PIC_PIC1PORT2, IRQ_PIC1);
     /* ICW4: i8086 mode */
-    outb(PIC_PIC1PORT2, 1);
+    pio_write_8(PIC_PIC1PORT2, 1);
     /*
      * Register interrupt handler for the PIC spurious interrupt.
 ,12 → 94,12
     uint8_t x;
     if (irqmask & 0xff) {
-        x = inb(PIC_PIC0PORT2);
-        outb(PIC_PIC0PORT2, (uint8_t) (x & (~(irqmask & 0xff))));
+        x = pio_read_8(PIC_PIC0PORT2);
+        pio_write_8(PIC_PIC0PORT2, (uint8_t) (x & (~(irqmask & 0xff))));
     }
     if (irqmask >> 8) {
-        x = inb(PIC_PIC1PORT2);
-        outb(PIC_PIC1PORT2, (uint8_t) (x & (~(irqmask >> 8))));
+        x = pio_read_8(PIC_PIC1PORT2);
+        pio_write_8(PIC_PIC1PORT2, (uint8_t) (x & (~(irqmask >> 8))));
     }
 }
 ,19 → 108,19
     uint8_t x;
     if (irqmask & 0xff) {
-        x = inb(PIC_PIC0PORT2);
-        outb(PIC_PIC0PORT2, (uint8_t) (x | (irqmask & 0xff)));
+        x = pio_read_8(PIC_PIC0PORT2);
+        pio_write_8(PIC_PIC0PORT2, (uint8_t) (x | (irqmask & 0xff)));
     }
     if (irqmask >> 8) {
-        x = inb(PIC_PIC1PORT2);
-        outb(PIC_PIC1PORT2, (uint8_t) (x | (irqmask >> 8)));
+        x = pio_read_8(PIC_PIC1PORT2);
+        pio_write_8(PIC_PIC1PORT2, (uint8_t) (x | (irqmask >> 8)));
     }
 }
 void pic_eoi(void)
 {
-    outb(0x20, 0x20);
-    outb(0xa0, 0x20);
+    pio_write_8(0x20, 0x20);
+    pio_write_8(0xa0, 0x20);
 }
 void pic_spurious(int n __attribute__((unused)), istate_t *istate __attribute__((unused)))

 /branches/dynload/kernel/arch/ia32/src/drivers/i8254.c
 ,12 → 61,12
 static irq_t i8254_irq;
-static irq_ownership_t i8254_claim(void)
+static irq_ownership_t i8254_claim(void *instance)
 {
     return IRQ_ACCEPT;
 }
-static void i8254_irq_handler(irq_t *irq, void *arg __attribute__((unused)), ...)
+static void i8254_irq_handler(irq_t *irq)
 {
     /*
      * This IRQ is responsible for kernel preemption.
 ,10 → 94,10
 void i8254_normal_operation(void)
 {
-    outb(CLK_PORT4, 0x36);
+    pio_write_8(CLK_PORT4, 0x36);
     pic_disable_irqs(1 << IRQ_CLK);
-    outb(CLK_PORT1, (CLK_CONST / HZ) & 0xf);
-    outb(CLK_PORT1, (CLK_CONST / HZ) >> 8);
+    pio_write_8(CLK_PORT1, (CLK_CONST / HZ) & 0xf);
+    pio_write_8(CLK_PORT1, (CLK_CONST / HZ) >> 8);
     pic_enable_irqs(1 << IRQ_CLK);
 }
 ,36 → 114,36
      * One-shot timer. Count-down from 0xffff at 1193180Hz
      * MAGIC_NUMBER is the magic value for 1ms.
      */
-    outb(CLK_PORT4, 0x30);
-    outb(CLK_PORT1, 0xff);
-    outb(CLK_PORT1, 0xff);
+    pio_write_8(CLK_PORT4, 0x30);
+    pio_write_8(CLK_PORT1, 0xff);
+    pio_write_8(CLK_PORT1, 0xff);
     do {
         /* will read both status and count */
-        outb(CLK_PORT4, 0xc2);
-        not_ok = (uint8_t) ((inb(CLK_PORT1) >> 6) & 1);
-        t1 = inb(CLK_PORT1);
-        t1 |= inb(CLK_PORT1) << 8;
+        pio_write_8(CLK_PORT4, 0xc2);
+        not_ok = (uint8_t) ((pio_read_8(CLK_PORT1) >> 6) & 1);
+        t1 = pio_read_8(CLK_PORT1);
+        t1 |= pio_read_8(CLK_PORT1) << 8;
     } while (not_ok);
     asm_delay_loop(LOOPS);
-    outb(CLK_PORT4, 0xd2);
-    t2 = inb(CLK_PORT1);
-    t2 |= inb(CLK_PORT1) << 8;
+    pio_write_8(CLK_PORT4, 0xd2);
+    t2 = pio_read_8(CLK_PORT1);
+    t2 |= pio_read_8(CLK_PORT1) << 8;
     /*
      * We want to determine the overhead of the calibrating mechanism.
      */
-    outb(CLK_PORT4, 0xd2);
-    o1 = inb(CLK_PORT1);
-    o1 |= inb(CLK_PORT1) << 8;
+    pio_write_8(CLK_PORT4, 0xd2);
+    o1 = pio_read_8(CLK_PORT1);
+    o1 |= pio_read_8(CLK_PORT1) << 8;
     asm_fake_loop(LOOPS);
-    outb(CLK_PORT4, 0xd2);
-    o2 = inb(CLK_PORT1);
-    o2 |= inb(CLK_PORT1) << 8;
+    pio_write_8(CLK_PORT4, 0xd2);
+    o2 = pio_read_8(CLK_PORT1);
+    o2 |= pio_read_8(CLK_PORT1) << 8;
     CPU->delay_loop_const =
         ((MAGIC_NUMBER * LOOPS) / 1000) / ((t1 - t2) - (o1 - o2)) +

 /branches/dynload/tools/config.py
 ,7 → 54,7
     inf.close()
 def check_condition(text, defaults, ask_names):
-    "Check for condition"
+    "Check that the condition specified on input line is True (only CNF and DNF is supported)"
     ctype = 'cnf'
 ,7 → 83,7
     return False
 def check_inside(text, defaults, ctype):
-    "Check that the condition specified on input line is True (only CNF is supported)"
+    "Check for condition"
     if (ctype == 'cnf'):
         conds = text.split('|')
 ,8 → 257,8
                 outmc.write('/* %s */\n#define %s\n\n' % (name, varname))
                 outdf.write(' -D%s' % varname)
         else:
-            outmc.write('/* %s */\n#define %s %s\n\n' % (name, varname, default))
-            outdf.write(' -D%s=%s' % (varname, default))
+            outmc.write('/* %s */\n#define %s %s\n#define %s_%s\n\n' % (name, varname, default, varname, default))
+            outdf.write(' -D%s=%s -D%s_%s' % (varname, default, varname, default))
     outmk.write('REVISION = %s\n' % revision)
     outmk.write('TIMESTAMP = %s\n' % timestamp)
 ,6 → 300,11
         selname = None
         while True:
+            # Cancel out all defaults which have to be deduced
+            for varname, vartype, name, choices, cond in ask_names:
+                if (vartype == 'y'):
+                    defaults[varname] = None
             options = []
             opt2row = {}
             position = None

 /branches/dynload/uspace/app/tetris/input.c
 ,7 → 114,7
         if (!getchar_inprog) {
             cons_phone = get_cons_phone();
             getchar_inprog = async_send_2(cons_phone,
-                CONSOLE_GETCHAR, 0, 0, &charcall);
+                CONSOLE_GETKEY, 0, 0, &charcall);
         }
         if (!s)
             async_wait_for(getchar_inprog, &rc);
 ,7 → 127,7
         if (rc) {
             stop("end of file, help");
         }
-        lastchar = IPC_GET_ARG1(charcall);
+        lastchar = IPC_GET_ARG4(charcall);
     }
     if (tvp) {
         /* since there is input, we may not have timed out */

 /branches/dynload/uspace/app/trace/trace.c
 ,7 → 519,7
     int rc;
     /* Spawn a program loader */
-    ldr = loader_spawn(path);
+    ldr = loader_connect();
     if (ldr == NULL)
         return 0;
 ,7 → 623,7
         V_INTEGER,
         V_INTEGER,
         V_INTEGER,
-        V_INTEGER
+        V_INTEGER
     };
     next_thread_id = 1;
 ,9 → 658,10
     proto_register(SERVICE_VFS, p);
     p = proto_new("console");
-    resp_def[0] = V_CHAR;
-    o = oper_new("getchar", 0, arg_def, V_INTEGER, 2, resp_def);
-    proto_add_oper(p, CONSOLE_GETCHAR, o);
+    resp_def[0] = V_INTEGER; resp_def[1] = V_INTEGER;
+    resp_def[2] = V_INTEGER; resp_def[3] = V_CHAR;
+    o = oper_new("getkey", 0, arg_def, V_ERRNO, 4, resp_def);
+    proto_add_oper(p, CONSOLE_GETKEY, o);
     arg_def[0] = V_CHAR;
     o = oper_new("putchar", 1, arg_def, V_VOID, 0, resp_def);

 /branches/dynload/uspace/lib/libc/include/kbd/keycode.h
 ,0 → 1,210
+/*
+ * Copyright (c) 2009 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_KBD_KEYCODE_H_
+#define LIBC_KBD_KEYCODE_H_
+/** Keycode definitions.
+ *
+ * A keycode identifies a key by its position on the keyboard, rather
+ * than by its label. For human readability, key positions are noted
+ * with the key label on a keyboard with US layout. This label has
+ * nothing to do with the character, that the key produces
+ * -- this is determined by the keymap.
+ *
+ * The keyboard model reflects a standard PC keyboard layout.
+ * Non-standard keyboards need to be mapped to this model in some
+ * logical way. Scancodes are mapped to keycodes with a scanmap.
+ *
+ * For easier mapping to the model and to emphasize the nature of keycodes,
+ * they really are organized here by position, rather than by label.
+ */
+enum keycode {
+    /* Main block row 1 */
+    KC_BACKTICK = 1,
+    KC_1,
+    KC_2,
+    KC_3,
+    KC_4,
+    KC_5,
+    KC_6,
+    KC_7,
+    KC_8,
+    KC_9,
+    KC_0,
+    KC_MINUS,
+    KC_EQUALS,
+    KC_BACKSPACE,
+    /* Main block row 2 */
+    KC_TAB,
+    KC_Q,
+    KC_W,
+    KC_E,
+    KC_R,
+    KC_T,
+    KC_Y,
+    KC_U,
+    KC_I,
+    KC_O,
+    KC_P,
+    KC_LBRACKET,
+    KC_RBRACKET,
+    /* Main block row 3 */
+    KC_CAPS_LOCK,
+    KC_A,
+    KC_S,
+    KC_D,
+    KC_F,
+    KC_G,
+    KC_H,
+    KC_J,
+    KC_K,
+    KC_L,
+    KC_SEMICOLON,
+    KC_QUOTE,
+    KC_BACKSLASH,
+    KC_ENTER,
+    /* Main block row 4 */
+    KC_LSHIFT,
+    KC_Z,
+    KC_X,
+    KC_C,
+    KC_V,
+    KC_B,
+    KC_N,
+    KC_M,
+    KC_COMMA,
+    KC_PERIOD,
+    KC_SLASH,
+    KC_RSHIFT,
+    /* Main block row 5 */
+    KC_LCTRL,
+    KC_LALT,
+    KC_SPACE,
+    KC_RALT,
+    KC_RCTRL,
+    /* Function keys block */
+    KC_ESCAPE,
+    KC_F1,
+    KC_F2,
+    KC_F3,
+    KC_F4,
+    KC_F5,
+    KC_F6,
+    KC_F7,
+    KC_F8,
+    KC_F9,
+    KC_F10,
+    KC_F11,
+    KC_F12,
+    KC_PRTSCR,
+    KC_SCROLL_LOCK,
+    KC_PAUSE,
+    /* Cursor keys block */
+    KC_INSERT,
+    KC_HOME,
+    KC_PAGE_UP,
+    KC_DELETE,
+    KC_END,
+    KC_PAGE_DOWN,
+    KC_UP,
+    KC_LEFT,
+    KC_DOWN,
+    KC_RIGHT,
+    /* Numeric block */
+    KC_NUM_LOCK,
+    KC_NSLASH,
+    KC_NTIMES,
+    KC_NMINUS,
+    KC_NPLUS,
+    KC_NENTER,
+    KC_N7,
+    KC_N8,
+    KC_N9,
+    KC_N4,
+    KC_N5,
+    KC_N6,
+    KC_N1,
+    KC_N2,
+    KC_N3,
+    KC_N0,
+    KC_NPERIOD
+} keycode_t;
+enum keymod {
+    KM_SHIFT    = 0x01,
+    KM_CTRL     = 0x02,
+    KM_ALT      = 0x04
+} keymod_t;
+#endif
+/** @}
+ */

 /branches/dynload/uspace/lib/libc/include/kbd/kbd.h
 ,0 → 1,63
+/*
+ * Copyright (c) 2009 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#ifndef LIBC_KBD_H_
+#define LIBC_KBD_H_
+typedef enum kbd_ev_type {
+    KE_PRESS,
+    KE_RELEASE
+} kbd_ev_type_t;
+/** Keyboard event structure. */
+typedef struct {
+    /** Press or release event. */
+    kbd_ev_type_t type;
+    /** Keycode of the key that was pressed or released. */
+    unsigned int key;
+    /** Bitmask of modifiers held. */
+    unsigned int mods;
+    /** The character that was generated or '\0' for none. */
+    char c;
+} kbd_event_t;
+extern int kbd_get_event(kbd_event_t *);
+#endif
+/** @}
+ */

 /branches/dynload/uspace/lib/libc/include/loader/loader.h
 ,7 → 44,8
     int phone_id;
 } loader_t;
-extern loader_t *loader_spawn(const char *name);
+extern int loader_spawn(const char *);
+extern loader_t *loader_connect(void);
 extern int loader_get_task_id(loader_t *, task_id_t *);
 extern int loader_set_pathname(loader_t *, const char *);
 extern int loader_set_args(loader_t *, char *const []);

 /branches/dynload/uspace/lib/libc/include/ipc/console.h
 ,7 → 38,7
 #include <ipc/ipc.h>
 typedef enum {
-    CONSOLE_GETCHAR = IPC_FIRST_USER_METHOD,
+    CONSOLE_GETKEY = IPC_FIRST_USER_METHOD,
     CONSOLE_PUTCHAR,
     CONSOLE_CLEAR,
     CONSOLE_GOTO,

 /branches/dynload/uspace/lib/libc/include/ipc/services.h
 ,7 → 38,8
 #define LIBIPC_SERVICES_H_
 typedef enum {
-    SERVICE_PCI = 1,
+    SERVICE_LOAD = 1,
+    SERVICE_PCI,
     SERVICE_KEYBOARD,
     SERVICE_VIDEO,
     SERVICE_CONSOLE,

 /branches/dynload/uspace/lib/libc/generic/kbd.c
 ,0 → 1,61
+/*
+ * Copyright (c) 2009 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+#include <stdio.h>
+#include <io/stream.h>
+#include <kbd/kbd.h>
+#include <ipc/ipc.h>
+#include <ipc/console.h>
+#include <async.h>
+int kbd_get_event(kbd_event_t *ev)
+{
+    int console_phone = get_cons_phone();
+    ipcarg_t r0, r1, r2, r3;
+    int rc;
+    rc = async_req_0_4(console_phone, CONSOLE_GETKEY, &r0, &r1, &r2, &r3);
+    if (rc < 0)
+        return -1;
+    ev->type = r0;
+    ev->key = r1;
+    ev->mods = r2;
+    ev->c = r3;
+    return 0;
+}
+/** @}
+ */

 /branches/dynload/uspace/lib/libc/generic/task.c
 ,8 → 63,8
     task_id_t task_id;
     int rc;
-    /* Spawn a program loader. */
-    ldr = loader_spawn(path);
+    /* Connect to a program loader. */
+    ldr = loader_connect();
     if (ldr == NULL)
         return 0;
 ,7 → 89,6
         goto error;
     /* Run it. */
-    /* Load the program. */
     rc = loader_run(ldr);
     if (rc != EOK)
         goto error;

 /branches/dynload/uspace/lib/libc/generic/loader.c
 ,6 → 34,7
 #include <ipc/ipc.h>
 #include <ipc/loader.h>
+#include <ipc/services.h>
 #include <libc.h>
 #include <task.h>
 #include <string.h>
 ,33 → 51,27
  * @return  Pointer to the loader connection structure (should be
  *      de-allocated using free() after use).
  */
-loader_t *loader_spawn(const char *name)
+int loader_spawn(const char *name)
 {
-    int phone_id, rc;
+    return __SYSCALL2(SYS_PROGRAM_SPAWN_LOADER,
+        (sysarg_t) name, strlen(name));
+}
+loader_t *loader_connect(void)
+{
     loader_t *ldr;
+    int phone_id;
-    /*
-     * Ask kernel to spawn a new loader task.
-     */
-    rc = __SYSCALL3(SYS_PROGRAM_SPAWN_LOADER, (sysarg_t) &phone_id,
-        (sysarg_t) name, strlen(name));
-    if (rc != 0)
+    phone_id = ipc_connect_me_to(PHONE_NS, SERVICE_LOAD, 0, 0);
+    if (phone_id < 0)
         return NULL;
-    /*
-     * Say hello so that the loader knows the incoming connection's
-     * phone hash.
-     */
-    rc = async_req_0_0(phone_id, LOADER_HELLO);
-    if (rc != EOK)
-        return NULL;
     ldr = malloc(sizeof(loader_t));
     if (ldr == NULL)
         return NULL;
     ldr->phone_id = phone_id;
-    return ldr;
+    return ldr;
 }
 /** Get ID of the new task.

 /branches/dynload/uspace/lib/libc/generic/io/stream.c
 ,6 → 43,7
 #include <ipc/fb.h>
 #include <ipc/services.h>
 #include <ipc/console.h>
+#include <kbd/kbd.h>
 #include <unistd.h>
 #include <async.h>
 #include <sys/types.h>
 ,13 → 59,17
 {
     open_console();
     if (console_phone >= 0) {
-        ipcarg_t r0, r1;
+        kbd_event_t ev;
+        int rc;
         size_t i = 0;
         while (i < count) {
-            if (async_req_0_2(console_phone, CONSOLE_GETCHAR, &r0, &r1) < 0)
-                return -1;
-            ((char *) buf)[i++] = r0;
+            do {
+                rc = kbd_get_event(&ev);
+                if (rc < 0) return -1;
+            } while (ev.c == 0 || ev.type == KE_RELEASE);
+            ((char *) buf)[i++] = ev.c;
         }
         return i;
     } else {

/branches/dynload/uspace/lib/libc/Makefile
84,6 → 84,7
generic/time.c \
generic/err.c \
generic/stdlib.c \
generic/kbd.c \
generic/mman.c \
generic/udebug.c \
generic/vfs/vfs.c \

/branches/dynload/uspace/srv/kbd/arch/amd64
File deleted
\ No newline at end of file
Property changes:
Deleted: svn:special
-*
\ No newline at end of property

/branches/dynload/uspace/srv/kbd/arch/mips32eb
File deleted
\ No newline at end of file
Property changes:
Deleted: svn:special
-*
\ No newline at end of property

 /branches/dynload/uspace/srv/kbd/ctl/pc.c
 ,0 → 1,164
+/*
+ * Copyright (c) 2009 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup kbd_ctl
+ * @ingroup kbd
+ * @{
+ */
+/**
+ * @file
+ * @brief   PC keyboard controller driver.
+ */
+#include <kbd.h>
+#include <kbd/kbd.h>
+#include <kbd/keycode.h>
+#include <kbd_ctl.h>
+static int scanmap_simple[];
+void kbd_ctl_parse_scancode(int scancode)
+{
+    kbd_ev_type_t type;
+    unsigned int key;
+    if (scancode < 0 || scancode >= 0x100)
+        return;
+    if (scancode & 0x80) {
+        scancode &= ~0x80;
+        type = KE_RELEASE;
+    } else {
+        type = KE_PRESS;
+    }
+    key = scanmap_simple[scancode];
+    if (key != 0)
+        kbd_push_ev(type, key, 0);
+}
+static int scanmap_simple[128] = {
+    [0x29] = KC_BACKTICK,
+    [0x02] = KC_1,
+    [0x03] = KC_2,
+    [0x04] = KC_3,
+    [0x05] = KC_4,
+    [0x06] = KC_5,
+    [0x07] = KC_6,
+    [0x08] = KC_7,
+    [0x09] = KC_8,
+    [0x0a] = KC_9,
+    [0x0b] = KC_0,
+    [0x0c] = KC_MINUS,
+    [0x0d] = KC_EQUALS,
+    [0x0e] = KC_BACKSPACE,
+    [0x0f] = KC_TAB,
+    [0x10] = KC_Q,
+    [0x11] = KC_W,
+    [0x12] = KC_E,
+    [0x13] = KC_R,
+    [0x14] = KC_T,
+    [0x15] = KC_Y,
+    [0x16] = KC_U,
+    [0x17] = KC_I,
+    [0x18] = KC_O,
+    [0x19] = KC_P,
+    [0x1a] = KC_LBRACKET,
+    [0x1b] = KC_RBRACKET,
+    [0x3a] = KC_CAPS_LOCK,
+    [0x1e] = KC_A,
+    [0x1f] = KC_S,
+    [0x20] = KC_D,
+    [0x21] = KC_F,
+    [0x22] = KC_G,
+    [0x23] = KC_H,
+    [0x24] = KC_J,
+    [0x25] = KC_K,
+    [0x26] = KC_L,
+    [0x27] = KC_SEMICOLON,
+    [0x28] = KC_QUOTE,
+    [0x2b] = KC_BACKSLASH,
+    [0x2a] = KC_LSHIFT,
+    [0x2c] = KC_Z,
+    [0x2d] = KC_X,
+    [0x2e] = KC_C,
+    [0x2f] = KC_V,
+    [0x30] = KC_B,
+    [0x31] = KC_N,
+    [0x32] = KC_M,
+    [0x33] = KC_COMMA,
+    [0x34] = KC_PERIOD,
+    [0x35] = KC_SLASH,
+    [0x36] = KC_RSHIFT,
+    [0x1d] = KC_LCTRL,
+    [0x38] = KC_LALT,
+    [0x39] = KC_SPACE,
+    [0x01] = KC_ESCAPE,
+    [0x3b] = KC_F1,
+    [0x3c] = KC_F2,
+    [0x3d] = KC_F3,
+    [0x3e] = KC_F4,
+    [0x3f] = KC_F5,
+    [0x40] = KC_F6,
+    [0x41] = KC_F7,
+    [0x42] = KC_F8,
+    [0x43] = KC_F9,
+    [0x44] = KC_F10,
+    [0x57] = KC_F11,
+    [0x58] = KC_F12,
+    [0x1c] = KC_ENTER
+/*
+    [0x1] = KC_PRNSCR,
+    [0x1] = KC_SCROLL_LOCK,
+    [0x1] = KC_PAUSE,
+*/
+};
+/**
+ * @}
+ */

 /branches/dynload/uspace/srv/kbd/ctl/stty.c
 ,0 → 1,261
+/*
+ * Copyright (c) 2009 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup kbd_ctl
+ * @ingroup kbd
+ * @{
+ */
+/**
+ * @file
+ * @brief   Serial TTY-like keyboard controller driver.
+ */
+#include <kbd.h>
+#include <kbd/kbd.h>
+#include <kbd/keycode.h>
+#include <kbd_ctl.h>
+static void parse_ds_start(int scancode);
+static void parse_ds_e(int scancode);
+static void parse_ds_e1(int scancode);
+static void parse_ds_e2(int scancode);
+static void parse_ds_e2a(int scancode);
+static void parse_ds_e2b(int scancode);
+static void parse_leaf(int scancode, int *map, size_t map_length);
+enum dec_state {
+    ds_start,
+    ds_e,
+    ds_e1,
+    ds_e2,
+    ds_e2a,
+    ds_e2b
+};
+static int map_start[] = {
+    [0x60] = KC_BACKTICK,
+    [0x31] = KC_1,
+    [0x32] = KC_2,
+    [0x33] = KC_3,
+    [0x34] = KC_4,
+    [0x35] = KC_5,
+    [0x36] = KC_6,
+    [0x37] = KC_7,
+    [0x38] = KC_8,
+    [0x39] = KC_9,
+    [0x30] = KC_0,
+    [0x2d] = KC_MINUS,
+    [0x3d] = KC_EQUALS,
+    [0x08] = KC_BACKSPACE,
+    [0x0f] = KC_TAB,
+    [0x71] = KC_Q,
+    [0x77] = KC_W,
+    [0x65] = KC_E,
+    [0x72] = KC_R,
+    [0x74] = KC_T,
+    [0x79] = KC_Y,
+    [0x75] = KC_U,
+    [0x69] = KC_I,
+    [0x6f] = KC_O,
+    [0x70] = KC_P,
+    [0x5b] = KC_LBRACKET,
+    [0x5d] = KC_RBRACKET,
+//  [0x3a] = KC_CAPS_LOCK,
+    [0x61] = KC_A,
+    [0x73] = KC_S,
+    [0x64] = KC_D,
+    [0x66] = KC_F,
+    [0x67] = KC_G,
+    [0x68] = KC_H,
+    [0x6a] = KC_J,
+    [0x6b] = KC_K,
+    [0x6c] = KC_L,
+    [0x3b] = KC_SEMICOLON,
+    [0x27] = KC_QUOTE,
+    [0x5c] = KC_BACKSLASH,
+//  [0x2a] = KC_LSHIFT,
+    [0x7a] = KC_Z,
+    [0x78] = KC_X,
+    [0x63] = KC_C,
+    [0x76] = KC_V,
+    [0x62] = KC_B,
+    [0x6e] = KC_N,
+    [0x6d] = KC_M,
+    [0x2c] = KC_COMMA,
+    [0x2e] = KC_PERIOD,
+    [0x2f] = KC_SLASH,
+//  [0x36] = KC_RSHIFT,
+//  [0x1d] = KC_LCTRL,
+//  [0x38] = KC_LALT,
+    [0x20] = KC_SPACE,
+    [0x1b] = KC_ESCAPE,
+    [0x0a] = KC_ENTER,
+    [0x0d] = KC_ENTER
+/*
+    [0x1] = KC_PRNSCR,
+    [0x1] = KC_SCROLL_LOCK,
+    [0x1] = KC_PAUSE,
+*/
+};
+static int map_e1[] =
+{
+    [0x50] = KC_F1,
+    [0x51] = KC_F2,
+    [0x52] = KC_F3,
+    [0x53] = KC_F4,
+};
+static int map_e2[] =
+{
+    [0x41] = KC_UP,
+    [0x42] = KC_DOWN,
+    [0x44] = KC_LEFT,
+    [0x43] = KC_RIGHT,
+};
+static int map_e2a[] =
+{
+    [0x35] = KC_F5,
+    [0x37] = KC_F6,
+    [0x38] = KC_F7,
+    [0x39] = KC_F8,
+};
+static int map_e2b[] =
+{
+    [0x30] = KC_F9,
+    [0x31] = KC_F10,
+    [0x32] = KC_F11,
+    [0x33] = KC_F12,
+};
+static enum dec_state ds;
+void kbd_ctl_parse_scancode(int scancode)
+{
+    switch (ds) {
+    case ds_start:  parse_ds_start(scancode); break;
+    case ds_e:  parse_ds_e(scancode); break;
+    case ds_e1: parse_ds_e1(scancode); break;
+    case ds_e2: parse_ds_e2(scancode); break;
+    case ds_e2a:    parse_ds_e2a(scancode); break;
+    case ds_e2b:    parse_ds_e2b(scancode); break;
+    }
+}
+static void parse_ds_start(int scancode)
+{
+    if (scancode < 0 || scancode >= sizeof(map_start) / sizeof(int))
+        return;
+    if (scancode == 0x1b) {
+        ds = ds_e;
+        return;
+    }
+    parse_leaf(scancode, map_start, sizeof(map_start) / sizeof(int));
+}
+static void parse_ds_e(int scancode)
+{
+    if (scancode < 0 || scancode >= 0x80) return;
+    switch (scancode) {
+    case 0x4f: ds = ds_e1; return;
+    case 0x5b: ds = ds_e2; return;
+    case 0x1b: ds = ds_start; break;
+    default: ds = ds_start; return;
+    }
+    kbd_push_ev(KE_PRESS, KC_ESCAPE, 0);
+}
+static void parse_ds_e1(int scancode)
+{
+    parse_leaf(scancode, map_e1, sizeof(map_e1) / sizeof(int));
+}
+static void parse_ds_e2(int scancode)
+{
+    switch (scancode) {
+    case 0x31: ds = ds_e2a; break;
+    case 0x32: ds = ds_e2b; break;
+    default: ds = ds_start; break;
+    }
+    parse_leaf(scancode, map_e2, sizeof(map_e2) / sizeof(int));
+}
+static void parse_ds_e2a(int scancode)
+{
+    parse_leaf(scancode, map_e2a, sizeof(map_e2a) / sizeof(int));
+}
+static void parse_ds_e2b(int scancode)
+{
+    parse_leaf(scancode, map_e2b, sizeof(map_e2b) / sizeof(int));
+}
+static void parse_leaf(int scancode, int *map, size_t map_length)
+{
+    unsigned int key;
+    ds = ds_start;
+    if (scancode < 0 || scancode >= map_length)
+        return;
+    key = map[scancode];
+    if (key != 0)
+        kbd_push_ev(KE_PRESS, key, 0);
+}
+/**
+ * @}
+ */

 /branches/dynload/uspace/srv/kbd/ctl/sun.c
 ,0 → 1,204
+/*
+ * Copyright (c) 2006 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup kbd_ctl
+ * @ingroup kbd
+ * @{
+ */
+/**
+ * @file
+ * @brief   Sun keyboard controller driver.
+ */
+#include <kbd.h>
+#include <kbd/kbd.h>
+#include <kbd/keycode.h>
+#include <kbd_ctl.h>
+#define KBD_KEY_RELEASE     0x80
+#define KBD_ALL_KEYS_UP     0x7f
+static int scanmap_simple[];
+void kbd_ctl_parse_scancode(int scancode)
+{
+    kbd_ev_type_t type;
+    unsigned int key;
+    if (scancode < 0 || scancode >= 0x100)
+        return;
+    if (scancode == KBD_ALL_KEYS_UP)
+        return;
+    if (scancode & KBD_KEY_RELEASE) {
+        scancode &= ~KBD_KEY_RELEASE;
+        type = KE_RELEASE;
+    } else {
+        type = KE_PRESS;
+    }
+    key = scanmap_simple[scancode];
+    if (key != 0)
+        kbd_push_ev(type, key, 0);
+}
+/** Primary meaning of scancodes. */
+static int scanmap_simple[] = {
+    [0x00] = 0,
+    [0x01] = 0,
+    [0x02] = 0,
+    [0x03] = 0,
+    [0x04] = 0,
+    [0x05] = KC_F1,
+    [0x06] = KC_F2,
+    [0x07] = KC_F10,
+    [0x08] = KC_F3,
+    [0x09] = KC_F11,
+    [0x0a] = KC_F4,
+    [0x0b] = KC_F12,
+    [0x0c] = KC_F5,
+    [0x0d] = KC_RALT,
+    [0x0e] = KC_F6,
+    [0x0f] = 0,
+    [0x10] = KC_F7,
+    [0x11] = KC_F8,
+    [0x12] = KC_F9,
+    [0x13] = KC_LALT,
+    [0x14] = KC_UP,
+    [0x15] = KC_PAUSE,
+    [0x16] = 0,
+    [0x17] = KC_SCROLL_LOCK,
+    [0x18] = KC_LEFT,
+    [0x19] = 0,
+    [0x1a] = 0,
+    [0x1b] = KC_DOWN,
+    [0x1c] = KC_RIGHT,
+    [0x1d] = KC_ESCAPE,
+    [0x1e] = KC_1,
+    [0x1f] = KC_2,
+    [0x20] = KC_3,
+    [0x21] = KC_4,
+    [0x22] = KC_5,
+    [0x23] = KC_6,
+    [0x24] = KC_7,
+    [0x25] = KC_8,
+    [0x26] = KC_9,
+    [0x27] = KC_0,
+    [0x28] = KC_MINUS,
+    [0x29] = KC_EQUALS,
+    [0x2a] = KC_BACKTICK,
+    [0x2b] = KC_BACKSPACE,
+    [0x2c] = KC_INSERT,
+    [0x2d] = 0,
+    [0x2e] = KC_NSLASH,
+    [0x2f] = KC_NTIMES,
+    [0x30] = 0,
+    [0x31] = 0,
+    [0x32] = KC_NPERIOD,
+    [0x33] = 0,
+    [0x34] = KC_HOME,
+    [0x35] = KC_TAB,
+    [0x36] = KC_Q,
+    [0x37] = KC_W,
+    [0x38] = KC_E,
+    [0x39] = KC_R,
+    [0x3a] = KC_T,
+    [0x3b] = KC_Y,
+    [0x3c] = KC_U,
+    [0x3d] = KC_I,
+    [0x3e] = KC_O,
+    [0x3f] = KC_P,
+    [0x40] = KC_LBRACKET,
+    [0x41] = KC_RBRACKET,
+    [0x42] = KC_DELETE,
+    [0x43] = 0,
+    [0x44] = KC_N7,
+    [0x45] = KC_N8,
+    [0x46] = KC_N9,
+    [0x47] = KC_NMINUS,
+    [0x48] = 0,
+    [0x49] = 0,
+    [0x4a] = KC_END,
+    [0x4b] = 0,
+    [0x4c] = KC_LCTRL,
+    [0x4d] = KC_A,
+    [0x4e] = KC_S,
+    [0x4f] = KC_D,
+    [0x50] = KC_F,
+    [0x51] = KC_G,
+    [0x52] = KC_H,
+    [0x53] = KC_J,
+    [0x54] = KC_K,
+    [0x55] = KC_L,
+    [0x56] = KC_SEMICOLON,
+    [0x57] = KC_QUOTE,
+    [0x58] = KC_BACKSLASH,
+    [0x59] = KC_ENTER,
+    [0x5a] = KC_NENTER,
+    [0x5b] = KC_N4,
+    [0x5c] = KC_N5,
+    [0x5d] = KC_N6,
+    [0x5e] = KC_N0,
+    [0x5f] = 0,
+    [0x60] = KC_PAGE_UP,
+    [0x61] = 0,
+    [0x62] = KC_NUM_LOCK,
+    [0x63] = KC_LSHIFT,
+    [0x64] = KC_Z,
+    [0x65] = KC_X,
+    [0x66] = KC_C,
+    [0x67] = KC_V,
+    [0x68] = KC_B,
+    [0x69] = KC_N,
+    [0x6a] = KC_M,
+    [0x6b] = KC_COMMA,
+    [0x6c] = KC_PERIOD,
+    [0x6d] = KC_SLASH,
+    [0x6e] = KC_RSHIFT,
+    [0x6f] = 0,
+    [0x70] = KC_N1,
+    [0x71] = KC_N2,
+    [0x72] = KC_N3,
+    [0x73] = 0,
+    [0x74] = 0,
+    [0x75] = 0,
+    [0x76] = 0,
+    [0x77] = KC_CAPS_LOCK,
+    [0x78] = 0,
+    [0x79] = KC_SPACE,
+    [0x7a] = 0,
+    [0x7b] = KC_PAGE_DOWN,
+    [0x7c] = 0,
+    [0x7d] = KC_NPLUS,
+    [0x7e] = 0,
+    [0x7f] = 0
+};
+/** @}
+ */

 /branches/dynload/uspace/srv/kbd/ctl/gxe_fb.c
 ,0 → 1,252
+/*
+ * Copyright (c) 2009 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup kbd_ctl
+ * @ingroup kbd
+ * @{
+ */
+/**
+ * @file
+ * @brief   GXEmul framebuffer-mode keyboard controller driver.
+ */
+#include <kbd.h>
+#include <kbd/kbd.h>
+#include <kbd/keycode.h>
+#include <kbd_ctl.h>
+static void parse_ds_start(int scancode);
+static void parse_ds_e(int scancode);
+static void parse_ds_e1(int scancode);
+static void parse_ds_e1a(int scancode);
+static void parse_ds_e1b(int scancode);
+static void parse_ds_e1c(int scancode);
+static void parse_leaf(int scancode, int *map, size_t map_length);
+enum dec_state {
+    ds_start,
+    ds_e,
+    ds_e1,
+    ds_e1a,
+    ds_e1b,
+    ds_e1c
+};
+static int map_start[] = {
+    [0x60] = KC_BACKTICK,
+    [0x31] = KC_1,
+    [0x32] = KC_2,
+    [0x33] = KC_3,
+    [0x34] = KC_4,
+    [0x35] = KC_5,
+    [0x36] = KC_6,
+    [0x37] = KC_7,
+    [0x38] = KC_8,
+    [0x39] = KC_9,
+    [0x30] = KC_0,
+    [0x2d] = KC_MINUS,
+    [0x3d] = KC_EQUALS,
+    [0x08] = KC_BACKSPACE,
+    [0x0f] = KC_TAB,
+    [0x71] = KC_Q,
+    [0x77] = KC_W,
+    [0x65] = KC_E,
+    [0x72] = KC_R,
+    [0x74] = KC_T,
+    [0x79] = KC_Y,
+    [0x75] = KC_U,
+    [0x69] = KC_I,
+    [0x6f] = KC_O,
+    [0x70] = KC_P,
+    [0x5b] = KC_LBRACKET,
+    [0x5d] = KC_RBRACKET,
+//  [0x3a] = KC_CAPS_LOCK,
+    [0x61] = KC_A,
+    [0x73] = KC_S,
+    [0x64] = KC_D,
+    [0x66] = KC_F,
+    [0x67] = KC_G,
+    [0x68] = KC_H,
+    [0x6a] = KC_J,
+    [0x6b] = KC_K,
+    [0x6c] = KC_L,
+    [0x3b] = KC_SEMICOLON,
+    [0x27] = KC_QUOTE,
+    [0x5c] = KC_BACKSLASH,
+//  [0x2a] = KC_LSHIFT,
+    [0x7a] = KC_Z,
+    [0x78] = KC_X,
+    [0x63] = KC_C,
+    [0x76] = KC_V,
+    [0x62] = KC_B,
+    [0x6e] = KC_N,
+    [0x6d] = KC_M,
+    [0x2c] = KC_COMMA,
+    [0x2e] = KC_PERIOD,
+    [0x2f] = KC_SLASH,
+//  [0x36] = KC_RSHIFT,
+//  [0x1d] = KC_LCTRL,
+//  [0x38] = KC_LALT,
+    [0x20] = KC_SPACE,
+    [0x1b] = KC_ESCAPE,
+    [0x0a] = KC_ENTER,
+    [0x0d] = KC_ENTER
+/*
+    [0x1] = KC_PRNSCR,
+    [0x1] = KC_SCROLL_LOCK,
+    [0x1] = KC_PAUSE,
+*/
+};
+static int map_e1[] =
+{
+};
+static int map_e1a[] =
+{
+    [0x50] = KC_F1,
+    [0x51] = KC_F2,
+    [0x52] = KC_F3,
+    [0x53] = KC_F4,
+};
+static int map_e1b[] =
+{
+    [0x33] = KC_F5,
+    [0x37] = KC_F6,
+    [0x38] = KC_F7,
+    [0x39] = KC_F8,
+};
+static int map_e1c[] =
+{
+    [0x38] = KC_F9,
+    [0x39] = KC_F10,
+    [0x33] = KC_F11,
+    [0x34] = KC_F12,
+};
+static enum dec_state ds = ds_start;
+void kbd_ctl_parse_scancode(int scancode)
+{
+    switch (ds) {
+    case ds_start:  parse_ds_start(scancode); break;
+    case ds_e:  parse_ds_e(scancode); break;
+    case ds_e1: parse_ds_e1(scancode); break;
+    case ds_e1a:    parse_ds_e1a(scancode); break;
+    case ds_e1b:    parse_ds_e1b(scancode); break;
+    case ds_e1c:    parse_ds_e1c(scancode); break;
+    }
+}
+static void parse_ds_start(int scancode)
+{
+    if (scancode == 0x1b) {
+        ds = ds_e;
+        return;
+    }
+    parse_leaf(scancode, map_start, sizeof(map_start) / sizeof(int));
+}
+static void parse_ds_e(int scancode)
+{
+    switch (scancode) {
+    case 0x5b: ds = ds_e1; return;
+    case 0x1b: ds = ds_start; break;
+    default: ds = ds_start; return;
+    }
+    kbd_push_ev(KE_PRESS, KC_ESCAPE, 0);
+}
+static void parse_ds_e1(int scancode)
+{
+    switch (scancode) {
+    case 0x4f: ds = ds_e1a; return;
+    case 0x31: ds = ds_e1b; return;
+    case 0x32: ds = ds_e1c; return;
+    default: ds = ds_start; break;
+    }
+    parse_leaf(scancode, map_e1, sizeof(map_e1) / sizeof(int));
+}
+static void parse_ds_e1a(int scancode)
+{
+    parse_leaf(scancode, map_e1a, sizeof(map_e1a) / sizeof(int));
+}
+static void parse_ds_e1b(int scancode)
+{
+    parse_leaf(scancode, map_e1b, sizeof(map_e1b) / sizeof(int));
+}
+static void parse_ds_e1c(int scancode)
+{
+    parse_leaf(scancode, map_e1c, sizeof(map_e1c) / sizeof(int));
+}
+static void parse_leaf(int scancode, int *map, size_t map_length)
+{
+    unsigned int key;
+    ds = ds_start;
+    if (scancode < 0 || scancode >= map_length)
+        return;
+    key = map[scancode];
+    if (key != 0)
+        kbd_push_ev(KE_PRESS, key, 0);
+}
+/**
+ * @}
+ */

 /branches/dynload/uspace/srv/kbd/include/layout.h
 ,0 → 1,49
+/*
+ * Copyright (c) 2009 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup kbdgen generic
+ * @brief   HelenOS generic uspace keyboard handler.
+ * @ingroup  kbd
+ * @{
+ */
+/** @file
+ */
+#ifndef KBD_LAYOUT_H_
+#define KBD_LAYOUT_H_
+#include <kbd/kbd.h>
+extern char layout_parse_ev(kbd_event_t *);
+#endif
+/**
+ * @}
+ */

 /branches/dynload/uspace/srv/kbd/include/kbd.h
 ,10 → 39,15
 #include <key_buffer.h>
-extern int kbd_arch_init(void);
-extern int kbd_arch_process(keybuffer_t *keybuffer, ipc_call_t *call);
-extern int mouse_arch_process(int phoneid, ipc_call_t *call);
+#define KBD_EVENT   1024
+#define KBD_MS_LEFT 1025
+#define KBD_MS_RIGHT    1026
+#define KBD_MS_MIDDLE   1027
+#define KBD_MS_MOVE 1028
+extern void kbd_push_scancode(int);
+extern void kbd_push_ev(int, unsigned int, unsigned int);
 #endif
 /**

 /branches/dynload/uspace/srv/kbd/include/key_buffer.h
 ,23 → 38,25
 #define __KEY_BUFFER_H__
 #include <sys/types.h>
+#include <kbd/kbd.h>
 /** Size of buffer for pressed keys */
 #define KEYBUFFER_SIZE 128
 typedef struct {
-    int fifo[KEYBUFFER_SIZE];
+    kbd_event_t fifo[KEYBUFFER_SIZE];
     unsigned long head;
     unsigned long tail;
     unsigned long items;
 } keybuffer_t;
-void keybuffer_free(keybuffer_t *keybuffer);
-void keybuffer_init(keybuffer_t *keybuffer);
-int keybuffer_available(keybuffer_t *keybuffer);
-int keybuffer_empty(keybuffer_t *keybuffer);
-void keybuffer_push(keybuffer_t *keybuffer, int key);
-int keybuffer_pop(keybuffer_t *keybuffer, int *c);
+extern void keybuffer_free(keybuffer_t *);
+extern void keybuffer_init(keybuffer_t *);
+extern int keybuffer_available(keybuffer_t *);
+extern int keybuffer_empty(keybuffer_t *);
+extern void keybuffer_push(keybuffer_t *, const kbd_event_t *);
+extern void keybuffer_push0(keybuffer_t *, int c);
+extern int keybuffer_pop(keybuffer_t *, kbd_event_t *);
 #endif

 /branches/dynload/uspace/srv/kbd/include/kbd_ctl.h
 ,0 → 1,47
+/*
+ * Copyright (c) 2009 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup kbdgen generic
+ * @brief   HelenOS generic uspace keyboard handler.
+ * @ingroup  kbd
+ * @{
+ */
+/** @file
+ */
+#ifndef KBD_CTL_H_
+#define KBD_CTL_H_
+extern void kbd_ctl_parse_scancode(int);
+#endif
+/**
+ * @}
+ */

 /branches/dynload/uspace/srv/kbd/include/kbd_port.h
 ,0 → 1,47
+/*
+ * Copyright (c) 2009 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup kbdgen generic
+ * @brief   HelenOS generic uspace keyboard handler.
+ * @ingroup  kbd
+ * @{
+ */
+/** @file
+ */
+#ifndef KBD_PORT_H_
+#define KBD_PORT_H_
+extern int kbd_port_init(void);
+#endif
+/**
+ * @}
+ */

 /branches/dynload/uspace/srv/kbd/port/z8530.c
 ,0 → 1,78
+/*
+ * Copyright (c) 2006 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup kbd_port
+ * @ingroup  kbd
+ * @{
+ */
+/** @file
+ * @brief   Z8530 keyboard port driver.
+ */
+#include <ipc/ipc.h>
+#include <async.h>
+#include <sysinfo.h>
+#include <kbd.h>
+#include <kbd_port.h>
+#include <sys/types.h>
+/** Top-half pseudocode for z8530. */
+irq_cmd_t z8530_cmds[] = {
+    {
+        CMD_MEM_READ_1,
+,      /**< Address. Will be patched in run-time. */
+,      /**< Value. Not used. */
+/**< Arg 1 will contain the result. */
+    }
+};
+irq_code_t z8530_kbd = {
+,
+    z8530_cmds
+};
+static void z8530_irq_handler(ipc_callid_t iid, ipc_call_t *call);
+int kbd_port_init(void)
+{
+    async_set_interrupt_received(z8530_irq_handler);
+    z8530_cmds[0].addr = (void *) sysinfo_value("kbd.address.virtual") + 6;
+    ipc_register_irq(sysinfo_value("kbd.inr"), sysinfo_value("kbd.devno"),
+, &z8530_kbd);
+    return 0;
+}
+static void z8530_irq_handler(ipc_callid_t iid, ipc_call_t *call)
+{
+    int scan_code = IPC_GET_ARG1(*call);
+    kbd_push_scancode(scan_code);
+}
+/** @}
+ */

 /branches/dynload/uspace/srv/kbd/port/sgcn.c
 ,0 → 1,141
+/*
+ * Copyright (c) 2008 Pavel Rimsky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup kbd_port
+ * @ingroup  kbd
+ * @{
+ */
+/** @file
+ * @brief   SGCN (Serengeti Console) keyboard port driver.
+ */
+#include <as.h>
+#include <ddi.h>
+#include <ipc/ipc.h>
+#include <async.h>
+#include <kbd.h>
+#include <kbd_port.h>
+#include <sysinfo.h>
+#include <stdio.h>
+/**
+ * SGCN buffer header. It is placed at the very beginning of the SGCN
+ * buffer.
+ */
+typedef struct {
+    /** hard-wired to "CON" */
+    char magic[4];
+    /** we don't need this */
+    char unused[8];
+    /** offset within the SGCN buffer of the input buffer start */
+    uint32_t in_begin;
+    /** offset within the SGCN buffer of the input buffer end */
+    uint32_t in_end;
+    /** offset within the SGCN buffer of the input buffer read pointer */
+    uint32_t in_rdptr;
+    /** offset within the SGCN buffer of the input buffer write pointer */
+    uint32_t in_wrptr;
+} __attribute__ ((packed)) sgcn_buffer_header_t;
+/*
+ * Returns a pointer to the object of a given type which is placed at the given
+ * offset from the console buffer beginning.
+ */
+#define SGCN_BUFFER(type, offset) \
+        ((type *) (sram_virt_addr + sram_buffer_offset + (offset)))
+/** Returns a pointer to the console buffer header. */
+#define SGCN_BUFFER_HEADER  (SGCN_BUFFER(sgcn_buffer_header_t, 0))
+/**
+ * Virtual address mapped to SRAM.
+ */
+static uintptr_t sram_virt_addr;
+/**
+ * SGCN buffer offset within SGCN.
+ */
+static uintptr_t sram_buffer_offset;
+static void sgcn_irq_handler(ipc_callid_t iid, ipc_call_t *call);
+/**
+ * Initializes the SGCN driver.
+ * Maps the physical memory (SRAM) and registers the interrupt.
+ */
+int kbd_port_init(void)
+{
+    async_set_interrupt_received(sgcn_irq_handler);
+    sram_virt_addr = (uintptr_t) as_get_mappable_page(sysinfo_value("sram.area.size"));
+    if (physmem_map((void *) sysinfo_value("sram.address.physical"),
+        (void *) sram_virt_addr, sysinfo_value("sram.area.size") / PAGE_SIZE,
+        AS_AREA_READ | AS_AREA_WRITE) != 0) {
+        printf("SGCN: uspace driver could not map physical memory.");
+        return -1;
+    }
+    sram_buffer_offset = sysinfo_value("sram.buffer.offset");
+    ipc_register_irq(sysinfo_value("kbd.inr"), sysinfo_value("kbd.devno"),
+, (void *) 0);
+    return 0;
+}
+/**
+ * Handler of the "key pressed" event. Reads codes of all the pressed keys from
+ * the buffer.
+ */
+static void sgcn_irq_handler(ipc_callid_t iid, ipc_call_t *call)
+{
+    char c;
+    uint32_t begin = SGCN_BUFFER_HEADER->in_begin;
+    uint32_t end = SGCN_BUFFER_HEADER->in_end;
+    uint32_t size = end - begin;
+    volatile char *buf_ptr = (volatile char *)
+        SGCN_BUFFER(char, SGCN_BUFFER_HEADER->in_rdptr);
+    volatile uint32_t *in_wrptr_ptr = &(SGCN_BUFFER_HEADER->in_wrptr);
+    volatile uint32_t *in_rdptr_ptr = &(SGCN_BUFFER_HEADER->in_rdptr);
+    while (*in_rdptr_ptr != *in_wrptr_ptr) {
+        c = *buf_ptr;
+        *in_rdptr_ptr = (((*in_rdptr_ptr) - begin + 1) % size) + begin;
+        buf_ptr = (volatile char *)
+            SGCN_BUFFER(char, SGCN_BUFFER_HEADER->in_rdptr);
+        kbd_push_scancode(c);
+    }
+}
+/** @}
+ */

 /branches/dynload/uspace/srv/kbd/port/gxemul.c
 ,0 → 1,84
+/*
+ * Copyright (c) 2007 Michal Kebrt
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup kbd_port
+ * @{
+ * @ingroup  kbd
+ */
+/** @file
+ * @brief   GXEmul keyboard port driver.
+ */
+#include <ipc/ipc.h>
+#include <async.h>
+#include <sysinfo.h>
+#include <kbd_port.h>
+#include <kbd.h>
+static irq_cmd_t gxemul_cmds[] = {
+    {
+        CMD_MEM_READ_1,
+        (void *) 0,
+,
+    }
+};
+static irq_code_t gxemul_kbd = {
+,
+    gxemul_cmds
+};
+static void gxemul_irq_handler(ipc_callid_t iid, ipc_call_t *call);
+/** Initializes keyboard handler. */
+int kbd_port_init(void)
+{
+    async_set_interrupt_received(gxemul_irq_handler);
+    gxemul_cmds[0].addr = (void *) sysinfo_value("kbd.address.virtual");
+    ipc_register_irq(sysinfo_value("kbd.inr"), sysinfo_value("kbd.devno"),
+, &gxemul_kbd);
+    return 0;
+}
+/** Process data sent when a key is pressed.
+ *
+ *  @param keybuffer Buffer of pressed keys.
+ *  @param call      IPC call.
+ *
+ *  @return Always 1.
+ */
+static void gxemul_irq_handler(ipc_callid_t iid, ipc_call_t *call)
+{
+    int scan_code = IPC_GET_ARG2(*call);
+    kbd_push_scancode(scan_code);
+}
+/** @}
+ */

 /branches/dynload/uspace/srv/kbd/port/ns16550.c
 ,0 → 1,89
+/*
+ * Copyright (c) 2006 Josef Cejka
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup kbd_port
+ * @ingroup  kbd
+ * @{
+ */
+/** @file
+ * @brief   NS16550 port driver.
+ */
+#include <ipc/ipc.h>
+#include <async.h>
+#include <sysinfo.h>
+#include <kbd.h>
+#include <kbd_port.h>
+#include <ddi.h>
+/* NS16550 registers */
+#define RBR_REG     0    /** Receiver Buffer Register. */
+#define IER_REG     1   /** Interrupt Enable Register. */
+#define IIR_REG     2   /** Interrupt Ident Register (read). */
+#define FCR_REG     2   /** FIFO control register (write). */
+#define LCR_REG     3   /** Line Control register. */
+#define MCR_REG     4   /** Modem Control Register. */
+#define LSR_REG     5   /** Line Status Register. */
+irq_cmd_t ns16550_cmds[1] = {
+    { CMD_PORT_READ_1, 0, 0, 2 },
+};
+irq_code_t ns16550_kbd = {
+,
+    ns16550_cmds
+};
+static void ns16550_irq_handler(ipc_callid_t iid, ipc_call_t *call);
+uint16_t ns16550_port;
+int kbd_port_init(void)
+{
+    async_set_interrupt_received(ns16550_irq_handler);
+    ns16550_port = sysinfo_value("kbd.port");
+    ns16550_kbd.cmds[0].addr = (void *) (ns16550_port + RBR_REG);
+    ipc_register_irq(sysinfo_value("kbd.inr"), sysinfo_value("kbd.devno"),
+, &ns16550_kbd);
+    iospace_enable(task_get_id(), ns16550_port, 8);
+    return 0;
+}
+#define LSR_DATA_READY  0x01
+static void ns16550_irq_handler(ipc_callid_t iid, ipc_call_t *call)
+{
+    int scan_code = IPC_GET_ARG2(*call);
+    kbd_push_scancode(scan_code);
+}
+/**
+ * @}
+ */

 /branches/dynload/uspace/srv/kbd/port/msim.c
 ,0 → 1,83
+/*
+ * Copyright (c) 2006 Josef Cejka
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup kbd_port
+ * @ingroup  kbd
+ * @{
+ */
+/** @file
+ * @brief   Msim keyboard port driver.
+ */
+#include <ipc/ipc.h>
+#include <async.h>
+#include <sysinfo.h>
+#include <kbd_port.h>
+#include <kbd.h>
+irq_cmd_t msim_cmds[1] = {
+    { CMD_MEM_READ_1, (void *) 0, 0, 2 }
+};
+irq_code_t msim_kbd = {
+,
+    msim_cmds
+};
+static void msim_irq_handler(ipc_callid_t iid, ipc_call_t *call);
+int kbd_port_init(void)
+{
+    async_set_interrupt_received(msim_irq_handler);
+    msim_cmds[0].addr = sysinfo_value("kbd.address.virtual");
+    ipc_register_irq(sysinfo_value("kbd.inr"), sysinfo_value("kbd.devno"),
+, &msim_kbd);
+    return 0;
+}
+static void msim_irq_handler(ipc_callid_t iid, ipc_call_t *call)
+{
+    int scan_code = IPC_GET_ARG2(*call);
+//  static int esc_count=0;
+//  if (scan_code == 0x1b) {
+//      esc_count++;
+//      if (esc_count == 3)
+//          __SYSCALL0(SYS_DEBUG_ENABLE_CONSOLE);
+//  } else {
+//      esc_count=0;
+//  }
+//  if (fb_fb)
+//      return kbd_arch_process_fb(keybuffer, scan_code);
+    kbd_push_scancode(scan_code);
+}
+/** @}
+*/

 /branches/dynload/uspace/srv/kbd/port/i8042.c
 ,0 → 1,158
+/*
+ * Copyright (c) 2001-2004 Jakub Jermar
+ * Copyright (c) 2006 Josef Cejka
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup kbd_port
+ * @ingroup kbd
+ * @{
+ */
+/** @file
+ * @brief i8042 port driver.
+ */
+#include <ipc/ipc.h>
+#include <async.h>
+#include <unistd.h>
+#include <sysinfo.h>
+#include <kbd_port.h>
+#include <kbd.h>
+#include "i8042.h"
+/* Interesting bits for status register */
+#define i8042_OUTPUT_FULL  0x1
+#define i8042_INPUT_FULL   0x2
+#define i8042_MOUSE_DATA   0x20
+/* Command constants */
+#define i8042_CMD_KBD 0x60
+#define i8042_CMD_MOUSE  0xd4
+/* Keyboard cmd byte */
+#define i8042_KBD_IE        0x1
+#define i8042_MOUSE_IE      0x2
+#define i8042_KBD_DISABLE   0x10
+#define i8042_MOUSE_DISABLE 0x20
+#define i8042_KBD_TRANSLATE 0x40
+/* Mouse constants */
+#define MOUSE_OUT_INIT  0xf4
+#define MOUSE_ACK       0xfa
+static irq_cmd_t i8042_cmds[2] = {
+    { CMD_PORT_READ_1, (void *) 0x64, 0, 1 },
+    { CMD_PORT_READ_1, (void *) 0x60, 0, 2 }
+};
+static irq_code_t i8042_kbd = {
+,
+    i8042_cmds
+};
+static void wait_ready(void) {
+    while (i8042_status_read() & i8042_INPUT_FULL)
+        ;
+}
+static void i8042_irq_handler(ipc_callid_t iid, ipc_call_t *call);
+int kbd_port_init(void)
+{
+//  int i;
+    int mouseenabled = 0;
+    async_set_interrupt_received(i8042_irq_handler);
+    iospace_enable(task_get_id(), (void *) i8042_DATA, 5);
+    /* Disable kbd, enable mouse */
+    i8042_command_write(i8042_CMD_KBD);
+    wait_ready();
+    i8042_command_write(i8042_CMD_KBD);
+    wait_ready();
+    i8042_data_write(i8042_KBD_DISABLE);
+    wait_ready();
+    /* Flush all current IO */
+    while (i8042_status_read() & i8042_OUTPUT_FULL)
+        i8042_data_read();
+    /* Initialize mouse */
+/*  i8042_command_write(i8042_CMD_MOUSE);
+    wait_ready();
+    i8042_data_write(MOUSE_OUT_INIT);
+    wait_ready();
+    int mouseanswer = 0;
+    for (i=0;i < 1000; i++) {
+        int status = i8042_status_read();
+        if (status & i8042_OUTPUT_FULL) {
+            int data = i8042_data_read();
+            if (status & i8042_MOUSE_DATA) {
+                mouseanswer = data;
+                break;
+            }
+        }
+        usleep(1000);
+    }*/
+//  if (mouseanswer == MOUSE_ACK) {
+//      /* enable mouse */
+//      mouseenabled = 1;
+//
+//      ipc_register_irq(sysinfo_value("mouse.inr"), sysinfo_value("mouse.devno"), 0, &i8042_kbd);
+//  }
+    /* Enable kbd */
+    ipc_register_irq(sysinfo_value("kbd.inr"), sysinfo_value("kbd.devno"), 0, &i8042_kbd);
+    int newcontrol = i8042_KBD_IE | i8042_KBD_TRANSLATE;
+    if (mouseenabled)
+        newcontrol |= i8042_MOUSE_IE;
+    i8042_command_write(i8042_CMD_KBD);
+    wait_ready();
+    i8042_data_write(newcontrol);
+    wait_ready();
+    return 0;
+}
+static void i8042_irq_handler(ipc_callid_t iid, ipc_call_t *call)
+{
+    int status = IPC_GET_ARG1(*call);
+    if ((status & i8042_MOUSE_DATA))
+        return 0;
+    int scan_code = IPC_GET_ARG2(*call);
+    kbd_push_scancode(scan_code);
+    return 1;
+}
+/**
+ * @}
+ */

 /branches/dynload/uspace/srv/kbd/port/dummy.c
 ,0 → 1,46
+/*
+ * Copyright (c) 2009 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup kbd_port
+ * @brief   Dummy keyboard port driver.
+ * @ingroup  kbd
+ * @{
+ */
+/** @file
+ */
+#include <kbd_port.h>
+#include <kbd.h>
+int kbd_port_init(void)
+{
+    return 0;
+}
+/** @}
+*/

 /branches/dynload/uspace/srv/kbd/port/i8042.h
 ,0 → 1,75
+/*
+ * Copyright (c) 2006 Josef Cejka
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup kbd_port
+ * @ingroup  kbd
+ * @{
+ */
+/** @file
+ * @brief i8042 port driver.
+ */
+#ifndef KBD_PORT_i8042_H_
+#define KBD_PORT_i8042_H_
+#include <ddi.h>
+#include <libarch/ddi.h>
+#define i8042_DATA      0x60
+#define i8042_STATUS    0X64
+typedef unsigned char u8;
+typedef short u16;
+static inline void i8042_data_write(u8 data)
+{
+    outb(i8042_DATA, data);
+}
+static inline u8 i8042_data_read(void)
+{
+    return inb(i8042_DATA);
+}
+static inline u8 i8042_status_read(void)
+{
+    return inb(i8042_STATUS);
+}
+static inline void i8042_command_write(u8 command)
+{
+    outb(i8042_STATUS, command);
+}
+#endif
+/**
+ * @}
+ */

 /branches/dynload/uspace/srv/kbd/generic/kbd.c
 ,13 → 42,16
 #include <stdlib.h>
 #include <stdio.h>
 #include <ipc/ns.h>
+#include <async.h>
 #include <errno.h>
-#include <arch/kbd.h>
+#include <libadt/fifo.h>
+#include <kbd/kbd.h>
 #include <kbd.h>
-#include <libadt/fifo.h>
 #include <key_buffer.h>
-#include <async.h>
-#include <keys.h>
+#include <kbd_port.h>
+#include <kbd_ctl.h>
+#include <layout.h>
 #define NAME "kbd"
 ,31 → 59,51
 int phone2cons = -1;
 keybuffer_t keybuffer;
-static void irq_handler(ipc_callid_t iid, ipc_call_t *call)
+void kbd_push_scancode(int scancode)
 {
-    int chr;
+    printf("scancode: 0x%x\n", scancode);
+    kbd_ctl_parse_scancode(scancode);
+}
-#ifdef MOUSE_ENABLED
-    if (mouse_arch_process(phone2cons, call))
-        return;
-#endif
-    kbd_arch_process(&keybuffer, call);
+#include <kbd/keycode.h>
+void kbd_push_ev(int type, unsigned int key, unsigned int mods)
+{
+    kbd_event_t ev;
-    if (cons_connected && phone2cons != -1) {
-        /*
-         * recode to ASCII - one interrupt can produce more than one
-         * code so result is stored in fifo
-         */
-        while (!keybuffer_empty(&keybuffer)) {
-            if (!keybuffer_pop(&keybuffer, (int *)&chr))
-                break;
+    printf("type: %d\n", type);
+    printf("mods: 0x%x\n", mods);
+    printf("keycode: %u\n", key);
-            async_msg_1(phone2cons, KBD_PUSHCHAR, chr);
-        }
-    }
+    ev.type = type;
+    ev.key = key;
+    ev.mods = mods;
+    ev.c = layout_parse_ev(&ev);
+    async_msg_4(phone2cons, KBD_EVENT, ev.type, ev.key, ev.mods, ev.c);
 }
+//static void irq_handler(ipc_callid_t iid, ipc_call_t *call)
+//{
+//  kbd_event_t ev;
+//
+//  kbd_arch_process(&keybuffer, call);
+//
+//  if (cons_connected && phone2cons != -1) {
+//      /*
+//       * One interrupt can produce more than one event so the result
+//       * is stored in a FIFO.
+//       */
+//      while (!keybuffer_empty(&keybuffer)) {
+//          if (!keybuffer_pop(&keybuffer, &ev))
+//              break;
+//
+//          async_msg_4(phone2cons, KBD_EVENT, ev.type, ev.key,
+//              ev.mods, ev.c);
+//      }
+//  }
+//}
 static void console_connection(ipc_callid_t iid, ipc_call_t *icall)
 {
     ipc_callid_t callid;
 ,6 → 142,7
 }
 int main(int argc, char **argv)
 {
     printf(NAME ": HelenOS Keyboard service\n");
 ,8 → 149,8
     ipcarg_t phonead;
-    /* Initialize arch dependent parts */
-    if (kbd_arch_init())
+    /* Initialize port driver. */
+    if (kbd_port_init())
         return -1;
     /* Initialize key buffer */
 ,8 → 157,8
     keybuffer_init(&keybuffer);
     async_set_client_connection(console_connection);
-    async_set_interrupt_received(irq_handler);
-    /* Register service at nameserver */
+    /* Register service at nameserver. */
     if (ipc_connect_to_me(PHONE_NS, SERVICE_KEYBOARD, 0, 0, &phonead) != 0)
         return -1;
 ,7 → 165,7
     printf(NAME ": Accepting connections\n");
     async_manager();
-    /* Never reached */
+    /* Not reached. */
     return 0;
 }

 /branches/dynload/uspace/srv/kbd/generic/key_buffer.c
 ,7 → 40,7
 /** Clear key buffer.
  */
-void keybuffer_free(keybuffer_t *keybuffer)
+void keybuffer_free(keybuffer_t *keybuffer)
 {
     futex_down(&keybuffer_futex);
     keybuffer->head = 0;
 ,15 → 75,18
     return (keybuffer->items == 0);
 }
-/** Push key to key buffer.
- * If buffer is full, character is ignored.
- * @param key code of stored key
+/** Push key event to key buffer.
+ *
+ * If the buffer is full, the event is ignored.
+ *
+ * @param keybuffer The keybuffer.
+ * @param ev        The event to push.
  */
-void keybuffer_push(keybuffer_t *keybuffer, int key)
+void keybuffer_push(keybuffer_t *keybuffer, const kbd_event_t *ev)
 {
     futex_down(&keybuffer_futex);
     if (keybuffer->items < KEYBUFFER_SIZE) {
-        keybuffer->fifo[keybuffer->tail] = key;
+        keybuffer->fifo[keybuffer->tail] = *ev;
         keybuffer->tail = (keybuffer->tail + 1) % KEYBUFFER_SIZE;
         keybuffer->items++;
     }
 ,16 → 93,25
     futex_up(&keybuffer_futex);
 }
-/** Pop character from buffer.
- * @param c pointer to space where to store character from buffer.
- * @return zero on empty buffer, nonzero else
+void keybuffer_push0(keybuffer_t *keybuffer, int c)
+{
+    kbd_event_t ev;
+    ev.key = c; ev.mods = 0; ev.c = c;
+    keybuffer_push(keybuffer, &ev);
+}
+/** Pop event from buffer.
+ *
+ * @param edst  Pointer to where the event should be saved.
+ * @return  Zero on empty buffer, nonzero otherwise.
  */
-int keybuffer_pop(keybuffer_t *keybuffer, int *c)
+int keybuffer_pop(keybuffer_t *keybuffer, kbd_event_t *edst)
 {
     futex_down(&keybuffer_futex);
     if (keybuffer->items > 0) {
         keybuffer->items--;
-        *c = (keybuffer->fifo[keybuffer->head]) ;
+        *edst = (keybuffer->fifo[keybuffer->head]) ;
         keybuffer->head = (keybuffer->head + 1) % KEYBUFFER_SIZE;
         futex_up(&keybuffer_futex);
         return 1;

 /branches/dynload/uspace/srv/kbd/Makefile
 ,53 → 46,72
     generic/kbd.c \
     generic/key_buffer.c
-ARCH_SOURCES = \
-    arch/$(UARCH)/src/kbd.c
+ARCH_SOURCES =
+GENARCH_SOURCES =
+ifeq ($(KBD_LAYOUT), us_qwerty)
+    GENARCH_SOURCES += layout/us_qwerty.c
+endif
+ifeq ($(KBD_LAYOUT), us_dvorak)
+    GENARCH_SOURCES += layout/us_dvorak.c
+endif
+ifeq ($(UARCH), amd64)
+    GENARCH_SOURCES += \
+        port/i8042.c \
+        ctl/pc.c
+endif
+ifeq ($(UARCH), arm32)
+    GENARCH_SOURCES += \
+        port/gxemul.c
+    ifeq ($(CONFIG_FB), y)
+        GENARCH_SOURCES += \
+            ctl/gxe_fb.c
+    else
+        GENARCH_SOURCES += \
+            ctl/stty.c
+    endif
+endif
 ifeq ($(UARCH), ia32)
-    ARCH_SOURCES += \
-        arch/$(UARCH)/src/mouse.c \
-        arch/$(UARCH)/src/scanc.c
-    GENARCH_SOURCES = \
-        genarch/src/kbd.c
-    CFLAGS += -DMOUSE_ENABLED
+    GENARCH_SOURCES += \
+        port/i8042.c \
+        ctl/pc.c
 endif
 ifeq ($(UARCH), ia64)
-    ARCH_SOURCES += \
-        arch/$(UARCH)/src/mouse.c \
-        arch/$(UARCH)/src/scanc.c \
-        arch/$(UARCH)/src/lkbd.c
-    GENARCH_SOURCES = \
-        genarch/src/kbd.c
-    CFLAGS += -DMOUSE_ENABLED
+    GENARCH_SOURCES += \
+        port/dummy.c \
+        ctl/stty.c
 endif
-ifeq ($(UARCH), amd64)
-    ARCH_SOURCES += \
-        arch/$(UARCH)/src/mouse.c \
-        arch/$(UARCH)/src/scanc.c
-    GENARCH_SOURCES = \
-        genarch/src/kbd.c
-    CFLAGS += -DMOUSE_ENABLED
+ifeq ($(MACHINE), msim)
+    GENARCH_SOURCES += \
+        port/msim.c \
+        ctl/stty.c
 endif
-ifeq ($(UARCH), sparc64)
-    ARCH_SOURCES += \
-        arch/$(UARCH)/src/scanc.c \
-        arch/$(UARCH)/src/sgcn.c
-    GENARCH_SOURCES = \
-        genarch/src/kbd.c \
-        genarch/src/nofb.c
+ifeq ($(MACHINE), lgxemul)
+    GENARCH_SOURCES += \
+        port/gxemul.c
+    ifeq ($(CONFIG_FB), y)
+        GENARCH_SOURCES += \
+            ctl/gxe_fb.c
+    else
+        GENARCH_SOURCES += \
+            ctl/stty.c
+    endif
 endif
-ifeq ($(UARCH), arm32)
-    ARCH_SOURCES += \
-        arch/$(UARCH)/src/kbd_gxemul.c
+ifeq ($(MACHINE), bgxemul)
+    GENARCH_SOURCES += \
+        port/gxemul.c \
+        ctl/stty.c
 endif
-ifeq ($(UARCH), mips32)
+ifeq ($(UARCH), ppc32)
     GENARCH_SOURCES += \
-        genarch/src/nofb.c
+        port/dummy.c \
+        ctl/stty.c
 endif
-ifeq ($(UARCH), mips32eb)
+ifeq ($(UARCH), sparc64)
     GENARCH_SOURCES += \
-        genarch/src/nofb.c
+        port/z8530.c \
+        ctl/sun.c
 endif
 GENERIC_OBJECTS := $(addsuffix .o,$(basename $(GENERIC_SOURCES)))

 /branches/dynload/uspace/srv/kbd/layout/us_qwerty.c
 ,0 → 1,113
+/*
+ * Copyright (c) 2009 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup kbd
+ * @brief   US QWERTY leyout.
+ * @{
+ */
+#include <kbd.h>
+#include <kbd/kbd.h>
+#include <kbd/keycode.h>
+#include <layout.h>
+static int map_normal[] = {
+    [KC_BACKTICK] = '`',
+    [KC_1] = '1',
+    [KC_2] = '2',
+    [KC_3] = '3',
+    [KC_4] = '4',
+    [KC_5] = '5',
+    [KC_6] = '6',
+    [KC_7] = '7',
+    [KC_8] = '8',
+    [KC_9] = '9',
+    [KC_0] = '0',
+    [KC_MINUS] = '-',
+    [KC_EQUALS] = '=',
+    [KC_BACKSPACE] = '\b',
+    [KC_TAB] = '\t',
+    [KC_Q] = 'q',
+    [KC_W] = 'w',
+    [KC_E] = 'e',
+    [KC_R] = 'r',
+    [KC_T] = 't',
+    [KC_Y] = 'y',
+    [KC_U] = 'u',
+    [KC_I] = 'i',
+    [KC_O] = 'o',
+    [KC_P] = 'p',
+    [KC_LBRACKET] = '[',
+    [KC_RBRACKET] = ']',
+    [KC_A] = 'a',
+    [KC_S] = 's',
+    [KC_D] = 'd',
+    [KC_F] = 'f',
+    [KC_G] = 'g',
+    [KC_H] = 'h',
+    [KC_J] = 'j',
+    [KC_K] = 'k',
+    [KC_L] = 'l',
+    [KC_SEMICOLON] = ';',
+    [KC_QUOTE] = '\'',
+    [KC_BACKSLASH] = '\\',
+    [KC_ENTER] = '\n',
+    [KC_Z] = 'z',
+    [KC_X] = 'x',
+    [KC_C] = 'c',
+    [KC_V] = 'v',
+    [KC_B] = 'b',
+    [KC_N] = 'n',
+    [KC_M] = 'm',
+    [KC_COMMA] = ',',
+    [KC_PERIOD] = '.',
+    [KC_SLASH] = '/',
+    [KC_SPACE] = ' '
+};
+char layout_parse_ev(kbd_event_t *ev)
+{
+    if (ev->key >= sizeof(map_normal) / sizeof(int))
+        return 0;
+    return map_normal[ev->key];
+}
+/**
+ * @}
+ */

 /branches/dynload/uspace/srv/kbd/layout/us_dvorak.c
 ,0 → 1,112
+/*
+ * Copyright (c) 2009 Jiri Svoboda
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup kbd
+ * @brief   US Dvorak Simplified Keyboard layout.
+ * @{
+ */
+#include <kbd.h>
+#include <kbd/kbd.h>
+#include <kbd/keycode.h>
+#include <layout.h>
+static int map_normal[] = {
+    [KC_BACKTICK] = '`',
+    [KC_1] = '1',
+    [KC_2] = '2',
+    [KC_3] = '3',
+    [KC_4] = '4',
+    [KC_5] = '5',
+    [KC_6] = '6',
+    [KC_7] = '7',
+    [KC_8] = '8',
+    [KC_9] = '9',
+    [KC_0] = '0',
+    [KC_MINUS] = '[',
+    [KC_EQUALS] = ']',
+    [KC_BACKSPACE] = '\b',
+    [KC_TAB] = '\t',
+    [KC_Q] = '\'',
+    [KC_W] = ',',
+    [KC_E] = '.',
+    [KC_R] = 'p',
+    [KC_T] = 'y',
+    [KC_Y] = 'f',
+    [KC_U] = 'g',
+    [KC_I] = 'c',
+    [KC_O] = 'r',
+    [KC_P] = 'l',
+    [KC_LBRACKET] = '/',
+    [KC_RBRACKET] = '=',
+    [KC_A] = 'a',
+    [KC_S] = 'o',
+    [KC_D] = 'e',
+    [KC_F] = 'u',
+    [KC_G] = 'i',
+    [KC_H] = 'd',
+    [KC_J] = 'h',
+    [KC_K] = 't',
+    [KC_L] = 'n',
+    [KC_SEMICOLON] = 's',
+    [KC_QUOTE] = '-',
+    [KC_BACKSLASH] = '\\',
+    [KC_Z] = ';',
+    [KC_X] = 'q',
+    [KC_C] = 'j',
+    [KC_V] = 'k',
+    [KC_B] = 'x',
+    [KC_N] = 'b',
+    [KC_M] = 'm',
+    [KC_COMMA] = 'w',
+    [KC_PERIOD] = 'v',
+    [KC_SLASH] = 'z',
+    [KC_ENTER] = '\n'
+};
+char layout_parse_ev(kbd_event_t *ev)
+{
+    if (ev->key >= sizeof(map_normal) / sizeof(int))
+        return 0;
+    return map_normal[ev->key];
+}
+/**
+ * @}
+ */

 /branches/dynload/uspace/srv/ns/ns.c
 ,6 → 40,7
 #include <ipc/ns.h>
 #include <ipc/services.h>
 #include <stdio.h>
+#include <bool.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <errno.h>
 ,6 → 48,7
 #include <libadt/list.h>
 #include <libadt/hash_table.h>
 #include <sysinfo.h>
+#include <loader/loader.h>
 #include <ddi.h>
 #include <as.h>
 ,6 → 60,11
 static int connect_to_service(ipcarg_t service, ipc_call_t *call,
     ipc_callid_t callid);
+void register_clonable(ipcarg_t service, ipcarg_t phone, ipc_call_t *call,
+    ipc_callid_t callid);
+void connect_to_clonable(ipcarg_t service, ipc_call_t *call,
+    ipc_callid_t callid);
 /* Static functions implementing NS hash table operations. */
 static hash_index_t ns_hash(unsigned long *key);
 static int ns_compare(unsigned long *key, hash_count_t keys, link_t *item);
 ,11 → 91,27
 static void *clockaddr = NULL;
 static void *klogaddr = NULL;
-static void get_as_area(ipc_callid_t callid, ipc_call_t *call, char *name,
-    void **addr)
+/** Request for connection to a clonable service. */
+typedef struct {
+    link_t link;
+    ipcarg_t service;
+    ipc_call_t call;
+    ipc_callid_t callid;
+} cs_req_t;
+/** List of clonable-service connection requests. */
+static link_t cs_req;
+/** Return true if @a service is clonable. */
+static bool service_clonable(int service)
 {
+    return service == SERVICE_LOAD;
+}
+static void get_as_area(ipc_callid_t callid, ipc_call_t *call, char *name, void **addr)
+{
     void *ph_addr;
     if (!*addr) {
         ph_addr = (void *) sysinfo_value(name);
         if (!ph_addr) {
 ,8 → 119,11
             return;
         }
         *addr = as_get_mappable_page(PAGE_SIZE);
-        physmem_map(ph_addr, *addr, 1,
-            AS_AREA_READ | AS_AREA_CACHEABLE);
+        if (physmem_map(ph_addr, *addr, 1,
+            AS_AREA_READ | AS_AREA_CACHEABLE) != 0) {
+            ipc_answer_0(callid, ENOENT);
+            return;
+        }
     }
     ipc_answer_2(callid, EOK, (ipcarg_t) *addr, AS_AREA_READ);
 }
 ,6 → 142,8
         printf(NAME ": No memory available\n");
         return ENOMEM;
     }
+    list_initialize(&cs_req);
     printf(NAME ": Accepting connections\n");
     while (1) {
 ,12 → 152,10
         case IPC_M_SHARE_IN:
             switch (IPC_GET_ARG3(call)) {
             case SERVICE_MEM_REALTIME:
-                get_as_area(callid, &call, "clock.faddr",
-                    &clockaddr);
+                get_as_area(callid, &call, "clock.faddr", &clockaddr);
                 break;
             case SERVICE_MEM_KLOG:
-                get_as_area(callid, &call, "klog.faddr",
-                    &klogaddr);
+                get_as_area(callid, &call, "klog.faddr", &klogaddr);
                 break;
             default:
                 ipc_answer_0(callid, ENOENT);
 ,15 → 168,27
             /*
              * Server requests service registration.
              */
-            retval = register_service(IPC_GET_ARG1(call),
-                IPC_GET_ARG5(call), &call);
+            if (service_clonable(IPC_GET_ARG1(call))) {
+                register_clonable(IPC_GET_ARG1(call),
+                    IPC_GET_ARG5(call), &call, callid);
+                continue;
+            } else {
+                retval = register_service(IPC_GET_ARG1(call),
+                    IPC_GET_ARG5(call), &call);
+            }
             break;
         case IPC_M_CONNECT_ME_TO:
             /*
              * Client requests to be connected to a service.
              */
-            retval = connect_to_service(IPC_GET_ARG1(call), &call,
-                callid);
+            if (service_clonable(IPC_GET_ARG1(call))) {
+                connect_to_clonable(IPC_GET_ARG1(call),
+                    &call, callid);
+                continue;
+            } else {
+                retval = connect_to_service(IPC_GET_ARG1(call),
+                    &call, callid);
+            }
             break;
         default:
             retval = ENOENT;
 ,11 → 205,11
 /** Register service.
  *
- * @param service Service to be registered.
- * @param phone Phone to be used for connections to the service.
- * @param call Pointer to call structure.
+ * @param service   Service to be registered.
+ * @param phone     Phone to be used for connections to the service.
+ * @param call      Pointer to call structure.
  *
- * @return Zero on success or a value from @ref errno.h.
+ * @return      Zero on success or a value from @ref errno.h.
  */
 int register_service(ipcarg_t service, ipcarg_t phone, ipc_call_t *call)
 {
 ,7 → 219,7
     };
     hashed_service_t *hs;
     if (hash_table_find(&ns_hash_table, keys)) {
         return EEXISTS;
     }
 ,9 → 240,9
 /** Connect client to service.
  *
- * @param service Service to be connected to.
- * @param call Pointer to call structure.
- * @param callid Call ID of the request.
+ * @param service   Service to be connected to.
+ * @param call      Pointer to call structure.
+ * @param callid    Call ID of the request.
  *
  * @return Zero on success or a value from @ref errno.h.
  */
 ,7 → 251,7
     unsigned long keys[3] = { service, 0, 0 };
     link_t *hlp;
     hashed_service_t *hs;
     hlp = hash_table_find(&ns_hash_table, keys);
     if (!hlp) {
         return ENOENT;
 ,6 → 261,82
         IPC_GET_ARG3(*call), 0, IPC_FF_NONE);
 }
+/** Register clonable service.
+ *
+ * @param service   Service to be registered.
+ * @param phone     Phone to be used for connections to the service.
+ * @param call      Pointer to call structure.
+ */
+void register_clonable(ipcarg_t service, ipcarg_t phone, ipc_call_t *call,
+    ipc_callid_t callid)
+{
+    int rc;
+    cs_req_t *csr;
+    if (list_empty(&cs_req)) {
+        /* There was no pending connection request. */
+        printf(NAME ": Unexpected clonable server.\n");
+        ipc_answer_0(callid, EBUSY);
+        return;
+    }
+    csr = list_get_instance(cs_req.next, cs_req_t, link);
+    list_remove(&csr->link);
+    /* Currently we can only handle a single type of clonable service. */
+    assert(csr->service == SERVICE_LOAD);
+    ipc_answer_0(callid, EOK);
+    rc = ipc_forward_fast(csr->callid, phone, IPC_GET_ARG2(csr->call),
+        IPC_GET_ARG3(csr->call), 0, IPC_FF_NONE);
+    free(csr);
+}
+/** Connect client to clonable service.
+ *
+ * @param service   Service to be connected to.
+ * @param call      Pointer to call structure.
+ * @param callid    Call ID of the request.
+ *
+ * @return      Zero on success or a value from @ref errno.h.
+ */
+void connect_to_clonable(ipcarg_t service, ipc_call_t *call,
+    ipc_callid_t callid)
+{
+    int rc;
+    cs_req_t *csr;
+    assert(service == SERVICE_LOAD);
+    csr = malloc(sizeof(cs_req_t));
+    if (csr == NULL) {
+        ipc_answer_0(callid, ENOMEM);
+        return;
+    }
+    /* Spawn a loader. */
+    rc = loader_spawn("loader");
+    if (rc < 0) {
+        free(csr);
+        ipc_answer_0(callid, rc);
+        return;
+    }
+    csr->service = service;
+    csr->call = *call;
+    csr->callid = callid;
+    /*
+     * We can forward the call only after the server we spawned connects
+     * to us. Meanwhile we might need to service more connection requests.
+     * Thus we store the call in a queue.
+     */
+    list_append(&csr->link, &cs_req);
+}
 /** Compute hash index into NS hash table.
  *
  * @param key Pointer keys. However, only the first key (i.e. service number)

 /branches/dynload/uspace/srv/console/console.c
 ,7 → 35,8
 #include <libc.h>
 #include <fb.h>
 #include <ipc/ipc.h>
-#include <keys.h>
+#include <kbd.h>
+#include <kbd/keycode.h>
 #include <ipc/fb.h>
 #include <ipc/services.h>
 #include <errno.h>
 ,7 → 298,7
     ipc_callid_t callid;
     ipc_call_t call;
     int retval;
-    int c;
+    kbd_event_t ev;
     connection_t *conn;
     int newcon;
 ,22 → 320,24
                 IPC_GET_ARG2(call));
             retval = 0;
             break;
-        case KBD_PUSHCHAR:
-            /* got key from keyboard driver */
+        case KBD_EVENT:
+            /* Got event from keyboard driver. */
             retval = 0;
-            c = IPC_GET_ARG1(call);
+            ev.type = IPC_GET_ARG1(call);
+            ev.key = IPC_GET_ARG2(call);
+            ev.mods = IPC_GET_ARG3(call);
+            ev.c = IPC_GET_ARG4(call);
             /* switch to another virtual console */
             conn = &connections[active_console];
-/*
- *          if ((c >= KBD_KEY_F1) && (c < KBD_KEY_F1 +
- *              CONSOLE_COUNT)) {
- */
-            if ((c >= 0x101) && (c < 0x101 + CONSOLE_COUNT)) {
-                if (c == 0x112)
+            if ((ev.key >= KC_F1) && (ev.key < KC_F1 +
+                CONSOLE_COUNT)) {
+                if (ev.key == KC_F12)
                     change_console(KERNEL_CONSOLE);
                 else
-                    change_console(c - 0x101);
+                    change_console(ev.key - KC_F1);
                 break;
             }
 ,14 → 344,14
             /* if client is awaiting key, send it */
             if (conn->keyrequest_counter > 0) {
                 conn->keyrequest_counter--;
-                ipc_answer_1(fifo_pop(conn->keyrequests), EOK,
-                    c);
+                ipc_answer_4(fifo_pop(conn->keyrequests), EOK,
+                    ev.type, ev.key, ev.mods, ev.c);
                 break;
             }
-            keybuffer_push(&conn->keybuffer, c);
+            keybuffer_push(&conn->keybuffer, &ev);
             retval = 0;
             break;
         default:
             retval = ENOENT;
 ,7 → 366,7
     ipc_callid_t callid;
     ipc_call_t call;
     int consnum;
-    ipcarg_t arg1, arg2, arg3;
+    ipcarg_t arg1, arg2, arg3, arg4;
     connection_t *conn;
     if ((consnum = find_free_connection()) == -1) {
 ,6 → 391,9
         arg1 = 0;
         arg2 = 0;
+        arg3 = 0;
+        arg4 = 0;
         switch (IPC_GET_METHOD(call)) {
         case IPC_M_PHONE_HUNGUP:
             gcons_notify_disconnect(consnum);
 ,7 → 464,7
             if (consnum == active_console)
                 curs_visibility(arg1);
             break;
-        case CONSOLE_GETCHAR:
+        case CONSOLE_GETKEY:
             if (keybuffer_empty(&conn->keybuffer)) {
                 /* buffer is empty -> store request */
                 if (conn->keyrequest_counter <
 ,12 → 480,15
                 }
                 continue;
             }
-            int ch;
-            keybuffer_pop(&conn->keybuffer, &ch);
-            arg1 = ch;
+            kbd_event_t ev;
+            keybuffer_pop(&conn->keybuffer, &ev);
+            arg1 = ev.type;
+            arg2 = ev.key;
+            arg3 = ev.mods;
+            arg4 = ev.c;
             break;
         }
-        ipc_answer_2(callid, EOK, arg1, arg2);
+        ipc_answer_4(callid, EOK, arg1, arg2, arg3, arg4);
     }
 }

 /branches/dynload/uspace/srv/rd/rd.c
 ,7 → 257,7
     int flags = AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE;
     int retval = physmem_map(rd_ph_addr, rd_addr,
         ALIGN_UP(rd_size, PAGE_SIZE) >> PAGE_WIDTH, flags);
     if (retval < 0) {
         printf(NAME ": Error mapping RAM disk\n");
         return false;

 /branches/dynload/uspace/srv/loader/main.c
 ,6 → 50,7
 #include <fcntl.h>
 #include <sys/types.h>
 #include <ipc/ipc.h>
+#include <ipc/services.h>
 #include <ipc/loader.h>
 #include <loader/pcb.h>
 #include <errno.h>
 ,6 → 82,8
 static bool is_dyn_linked;
+/** Used to limit number of connections to one. */
+static bool connected;
 static void loader_get_taskid(ipc_callid_t rid, ipc_call_t *request)
 {
 ,6 → 308,17
     ipc_call_t call;
     int retval;
+    /* Already have a connection? */
+    if (connected) {
+        ipc_answer_0(iid, ELIMIT);
+        return;
+    }
+    connected = true;
+    /* Accept the connection */
+    ipc_answer_0(iid, EOK);
     /* Ignore parameters, the connection is already open */
     (void)iid; (void)icall;
 ,31 → 360,20
  */
 int main(int argc, char *argv[])
 {
-    ipc_callid_t callid;
-    ipc_call_t call;
-    ipcarg_t phone_hash;
+    ipcarg_t phonead;
-    /* The first call only communicates the incoming phone hash */
-    callid = ipc_wait_for_call(&call);
+    connected = false;
+    /* Set a handler of incomming connections. */
+    async_set_client_connection(loader_connection);
-    if (IPC_GET_METHOD(call) != LOADER_HELLO) {
-        if (IPC_GET_METHOD(call) != IPC_M_PHONE_HUNGUP)
-            ipc_answer_0(callid, EINVAL);
-        return 1;
-    }
-    ipc_answer_0(callid, EOK);
-    phone_hash = call.in_phone_hash;
-    /*
-     * Up until now async must not be used as it couldn't
-     * handle incoming requests. (Which means e.g. printf()
-     * cannot be used)
-     */
-    async_new_connection(phone_hash, 0, NULL, loader_connection);
+    /* Register at naming service. */
+    if (ipc_connect_to_me(PHONE_NS, SERVICE_LOAD, 0, 0, &phonead) != 0)
+        return -1;
     async_manager();
-    /* not reached */
+    /* Never reached */
     return 0;
 }

 /branches/dynload/uspace/srv/fb/msim.c
 ,7 → 59,8
     void *phys_addr = (void *) sysinfo_value("fb.address.physical");
     virt_addr = (char *) as_get_mappable_page(1);
-    physmem_map(phys_addr, virt_addr, 1, AS_AREA_READ | AS_AREA_WRITE);
+    if (physmem_map(phys_addr, virt_addr, 1, AS_AREA_READ | AS_AREA_WRITE) != 0)
+        return -1;
     serial_console_init(msim_putc, WIDTH, HEIGHT);

 /branches/dynload/uspace/srv/fb/fb.c
 ,8 → 1671,9
     unsigned int fbsize = fb_scanline * fb_height;
     void *fb_addr = as_get_mappable_page(fbsize);
-    physmem_map(fb_ph_addr + fb_offset, fb_addr,
-        ALIGN_UP(fbsize, PAGE_SIZE) >> PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE);
+    if (physmem_map(fb_ph_addr + fb_offset, fb_addr,
+        ALIGN_UP(fbsize, PAGE_SIZE) >> PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE) != 0)
+        return -1;
     if (screen_init(fb_addr, fb_width, fb_height, fb_scanline, fb_visual))
         return 0;

 /branches/dynload/uspace/srv/fb/sgcn.c
 ,19 → 121,13
  */
 int sgcn_init(void)
 {
-    sram_virt_addr = (uintptr_t) as_get_mappable_page(
-        sysinfo_value("sram.area.size"));
-    int result = physmem_map(
-        (void *) sysinfo_value("sram.address.physical"),
-        (void *) sram_virt_addr,
-        sysinfo_value("sram.area.size") / PAGE_SIZE,
-        AS_AREA_READ | AS_AREA_WRITE
-        );
-    if (result != 0) {
-        printf("SGCN: uspace driver couldn't map physical memory: %d\n",
-            result);
-    }
+    sram_virt_addr = (uintptr_t) as_get_mappable_page(sysinfo_value("sram.area.size"));
+    if (physmem_map((void *) sysinfo_value("sram.address.physical"),
+        (void *) sram_virt_addr, sysinfo_value("sram.area.size") / PAGE_SIZE,
+        AS_AREA_READ | AS_AREA_WRITE) != 0)
+        return -1;
     serial_console_init(sgcn_putc, WIDTH, HEIGHT);
     sram_buffer_offset = sysinfo_value("sram.buffer.offset");

 /branches/dynload/uspace/srv/fb/ega.c
 ,7 → 373,7
     scr_width = sysinfo_value("fb.width");
     scr_height = sysinfo_value("fb.height");
-    if(sysinfo_value("fb.blinking")) {
+    if (sysinfo_value("fb.blinking")) {
         ega_normal_color &= 0x77;
         ega_inverted_color &= 0x77;
     }
 ,8 → 385,9
     sz = scr_width * scr_height * 2;
     scr_addr = as_get_mappable_page(sz);
-    physmem_map(ega_ph_addr, scr_addr, ALIGN_UP(sz, PAGE_SIZE) >>
-        PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE);
+    if (physmem_map(ega_ph_addr, scr_addr, ALIGN_UP(sz, PAGE_SIZE) >>
+        PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE) != 0)
+        return -1;
     async_set_client_connection(ega_client_connection);

 /branches/dynload/HelenOS.config
 ,6 → 48,10
 ! [PLATFORM=mips32] MACHINE (choice)
 % Machine type
+@ "gxemul" GXEmul
+! [PLATFORM=arm32] MACHINE (choice)
+% Machine type
 @ "i460GX" i460GX chipset machine
 @ "ski" Ski ia64 simulator
 ! [PLATFORM=ia64] MACHINE (choice)
 ,7 → 142,7
 % User space architecture
 @ "mips32eb"
-! [PLATFORM=mips32&(MACHINE=bgxemul)] UARCH (choice)
+! [PLATFORM=mips32&MACHINE=bgxemul] UARCH (choice)
 % User space architecture
 @ "ppc32"
 ,8 → 246,11
 ! [PLATFORM=ia32&(MACHINE=athlon-xp|MACHINE=athlon-mp|MACHINE=pentium3)] CONFIG_FENCES_P3 (y)
 % Fences
-! [(PLATFORM=ia32&(MACHINE=pentium4|MACHINE=core))|PLATFORM=amd64] CONFIG_FENCES_P4 (y)
+! [PLATFORM=ia32&(MACHINE=pentium4|MACHINE=core)] CONFIG_FENCES_P4 (y)
+% Fences
+! [PLATFORM=amd64] CONFIG_FENCES_P4 (y)
 % ACPI support
 ! [PLATFORM=ia32|PLATFORM=amd64] CONFIG_ACPI (y)
 ,19 → 282,22
 ! [PLATFORM=sparc64] CONFIG_OFW_TREE (y)
 % FPU support
-! [PLATFORM=ia32|PLATFORM=amd64|PLATFORM=ia64|PLATFORM=sparc64|(PLATFORM=mips32&(MACHINE=lgxemul|MACHINE=bgxemul))] CONFIG_FPU (y)
+! [PLATFORM=ia32|PLATFORM=amd64|PLATFORM=ia64|PLATFORM=sparc64] CONFIG_FPU (y)
+% FPU support
+! [PLATFORM=mips32&(MACHINE=lgxemul|MACHINE=bgxemul)] CONFIG_FPU (y)
 ## Kernel features options
 % Support for SMP
-! [(PLATFORM=ia32&MACHINE!=athlon-xp)|PLATFORM=amd64|PLATFORM=sparc64|PLATFORM=ia64] CONFIG_SMP (y/n)
+! [(PLATFORM=ia32&MACHINE!=athlon-xp)|PLATFORM=amd64|PLATFORM=sparc64|PLATFORM=ia64|(PLATFORM=mips32&MACHINE=msim)] CONFIG_SMP (y/n)
 % Improved support for hyperthreading
-! [((PLATFORM=ia32&MACHINE!=athlon-xp&MACHINE!=athlon-mp&MACHINE!=pentium3)|PLATFORM=amd64)&CONFIG_SMP=y] CONFIG_HT (y/n)
+! [PLATFORM=amd64&CONFIG_SMP=y] CONFIG_HT (y/n)
-% Simics BIOS AP boot fix
-! [(PLATFORM=ia32|PLATFORM=amd64)&CONFIG_SMP=y] CONFIG_SIMICS_FIX (y/n)
+% Improved support for hyperthreading
+! [PLATFORM=ia32&MACHINE!=athlon-xp&MACHINE!=athlon-mp&MACHINE!=pentium3&CONFIG_SMP=y] CONFIG_HT (y/n)
 % Lazy FPU context switching
 ! [CONFIG_FPU=y] CONFIG_FPU_LAZY (y/n)
 ,25 → 312,22
 ! [PLATFORM=sparc64] CONFIG_Z8530 (y/n)
 % Support for NS16550 serial port
-! [PLATFORM=sparc64|(PLATFORM=ia64&MACHINE!=ski)] CONFIG_NS16550 (n/y)
+! [PLATFORM=sparc64] CONFIG_NS16550 (y/n)
-% IOSapic on default address support
-! [PLATFORM=ia64&MACHINE!=ski] CONFIG_IOSAPIC (y/n)
+% Support for NS16550 serial port
+! [PLATFORM=ia64&MACHINE!=ski] CONFIG_NS16550 (n/y)
-% Interrupt-driven driver for Legacy Keyboard
-! [CONFIG_NS16550=n&CONFIG_IOSAPIC=y&MACHINE!=ski] CONFIG_I8042_INTERRUPT_DRIVEN (y/n)
-% Interrupt-driven driver for NS16550
-! [CONFIG_NS16550=y&((PLATFORM!=ia64)|CONFIG_IOSAPIC=y)&MACHINE!=ski] CONFIG_NS16550_INTERRUPT_DRIVEN (y/n)
 % Support for Serengeti console
 ! [PLATFORM=sparc64] CONFIG_SGCN (y/n)
+% IOSapic on default address support
+! [PLATFORM=ia64&MACHINE!=ski] CONFIG_IOSAPIC (y/n)
 % Virtually indexed D-cache support
 ! [PLATFORM=sparc64] CONFIG_VIRT_IDX_DCACHE (y/n)
 % Support for userspace debuggers
-! CONFIG_UDEBUG (n/y)
+! CONFIG_UDEBUG (y/n)
 % Kernel console support
 ! CONFIG_KCONSOLE (y/n)
 ,12 → 338,6
 % Deadlock detection support for spinlocks
 ! [CONFIG_DEBUG=y&CONFIG_SMP=y] CONFIG_DEBUG_SPINLOCK (y/n)
-% Watchpoint on rewriting AS with zero
-! [CONFIG_DEBUG=y&(PLATFORM=amd64|PLATFORM=ia32)] CONFIG_DEBUG_AS_WATCHPOINT (y/n)
-% Save all interrupt registers
-! [CONFIG_DEBUG=y&(PLATFORM=amd64|PLATFORM=mips32|PLATFORM=ia32)] CONFIG_DEBUG_ALLREGS (y/n)
 % Compile kernel tests
 ! CONFIG_TEST (y/n)
 ,7 → 345,7
 ## Hardware support
 % Framebuffer support
-! [(PLATFORM=mips32&MACHINE=lgxemul)|(PLATFORM=mips32&MACHINE=bgxemul)|(PLATFORM=ia32)|(PLATFORM=amd64)|(PLATFORM=arm32)|(PLATFORM=sparc64&MACHINE=us3)] CONFIG_FB (y/n)
+! [(PLATFORM=mips32&MACHINE=lgxemul)|(PLATFORM=mips32&MACHINE=bgxemul)|PLATFORM=ia32|PLATFORM=amd64|PLATFORM=arm32|(PLATFORM=sparc64&MACHINE=us3)] CONFIG_FB (y/n)
 % Framebuffer support
 ! [PLATFORM=ppc32|(PLATFORM=sparc64&MACHINE=us)] CONFIG_FB (y)
 ,5 → 393,10
 % External ramdisk
 ! [PLATFORM=sparc64] CONFIG_RD_EXTERNAL (y/n)
+% Keyboard layout
+@ "us_qwerty" US QWERTY
+@ "us_dvorak" US Dvorak
+! KBD_LAYOUT (choice)
 % Use shared C library
 ! CONFIG_SHARED_LIBC (y/n)

 /branches/dynload/boot/generic/align.h
 ,7 → 26,7
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 /** @file

 /branches/dynload/boot/generic/macros.h
 ,15 → 35,18
 #ifndef BOOT_MACROS_H_
 #define BOOT_MACROS_H_
-#define SIZE2KB(size) ((size) >> 10)
-#define SIZE2MB(size) ((size) >> 20)
+#define min(a, b)  ((a) < (b) ? (a) : (b))
+#define max(a, b)  ((a) > (b) ? (a) : (b))
-#define KB2SIZE(kb) ((kb) << 10)
-#define MB2SIZE(mb) ((mb) << 20)
+#define SIZE2KB(size)  ((size) >> 10)
+#define SIZE2MB(size)  ((size) >> 20)
-#define STRING(arg) STRING_ARG(arg)
-#define STRING_ARG(arg) #arg
+#define KB2SIZE(kb)  ((kb) << 10)
+#define MB2SIZE(mb)  ((mb) << 20)
+#define STRING(arg)      STRING_ARG(arg)
+#define STRING_ARG(arg)  #arg
 #endif
 /** @}

/branches/dynload/boot/arch/arm32/loader/boot.S
53,5 → 53,3
# make place for PTL0 page table
page_table:
.skip PTL0_ENTRIES * PTL0_ENTRY_SIZE

 /branches/dynload/boot/arch/arm32/loader/main.c
 ,7 → 32,7
  */
 /** @file
  *  @brief Bootstrap.
- */
+ */
 #include "main.h"
 ,6 → 39,7
 #include "asm.h"
 #include "_components.h"
 #include <printf.h>
+#include <align.h>
 #include <macros.h>
 #include "mm.h"
 ,7 → 110,7
     }
     printf("\nBooting the kernel...\n");
-    jump_to_kernel((void *) KERNEL_VIRTUAL_ADDRESS, &bootinfo, sizeof(bootinfo));
+    jump_to_kernel((void *) KERNEL_VIRTUAL_ADDRESS, &bootinfo);
 }
 /** @}

 /branches/dynload/boot/arch/arm32/loader/asm.h
 ,7 → 32,7
  */
 /** @file
  *  @brief Functions implemented in assembly.
- */
+ */
 #ifndef BOOT_arm32_ASM_H
 ,10 → 40,10
 /** Copies cnt bytes from dst to src.
- *
+ *
  * @param dst Destination address.
  * @param src Source address.
- * @param cnt Count of bytes to be copied.
+ * @param cnt Count of bytes to be copied.
  */
 #define memcpy(dst, src, cnt) __builtin_memcpy((dst), (src), (cnt))
 ,12 → 58,11
 /** Jumps to the kernel entry point.
  *
- * @param entry          Kernel entry point address.
- * @param bootinfo       Structure holding information about loaded tasks.
- * @param bootinfo_size  Size of the bootinfo structure.
+ * @param entry    Kernel entry point address.
+ * @param bootinfo Structure holding information about loaded tasks.
+ *
  */
-extern void jump_to_kernel(void *entry, void *bootinfo,
-    unsigned int bootinfo_size) __attribute__((noreturn));
+extern void jump_to_kernel(void *entry, void *bootinfo) __attribute__((noreturn));
 #endif

 /branches/dynload/boot/arch/arm32/loader/main.h
 ,7 → 32,7
  */
 /** @file
  *  @brief Boot related declarations.
- */
+ */
 #ifndef BOOT_arm32_MAIN_H
 ,13 → 39,6
 #define BOOT_arm32_MAIN_H
-/** Aligns to the nearest higher address.
- *
- * @param addr  Address or number to be aligned.
- * @param align Size of alignment, must be power of 2.
- */
-#define ALIGN_UP(addr, align) (((addr) + ((align) - 1)) & ~((align) - 1))
 /** Maximum number of tasks in the #bootinfo_t struct. */
 #define TASKMAP_MAX_RECORDS 32
 ,4 → 67,3
 /** @}
  */

 /branches/dynload/boot/arch/mips32/loader/boot.S
 ,9 → 27,8
 #
 #include "regname.h"
+#include "main.h"
-#define INITIAL_STACK 0x80040000
 .set noat
 .set noreorder
 .set nomacro
 ,8 → 37,82
 .global start
 start:
-    lui $sp, INITIAL_STACK >> 16
-    ori $sp, $sp, INITIAL_STACK & 0xffff
-    j bootstrap
+    /* Setup CPU map (on msim this code
+       is executed in parallel on all CPUs,
+       but it not an issue) */
+    la $a0, CPUMAP
+    sw $zero, 0($a0)
+    sw $zero, 4($a0)
+    sw $zero, 8($a0)
+    sw $zero, 12($a0)
+    sw $zero, 16($a0)
+    sw $zero, 20($a0)
+    sw $zero, 24($a0)
+    sw $zero, 28($a0)
+    sw $zero, 32($a0)
+    sw $zero, 36($a0)
+    sw $zero, 40($a0)
+    sw $zero, 44($a0)
+    sw $zero, 48($a0)
+    sw $zero, 52($a0)
+    sw $zero, 56($a0)
+    sw $zero, 60($a0)
+    sw $zero, 64($a0)
+    sw $zero, 68($a0)
+    sw $zero, 72($a0)
+    sw $zero, 76($a0)
+    sw $zero, 80($a0)
+    sw $zero, 84($a0)
+    sw $zero, 88($a0)
+    sw $zero, 92($a0)
+    sw $zero, 96($a0)
+    sw $zero, 100($a0)
+    sw $zero, 104($a0)
+    sw $zero, 108($a0)
+    sw $zero, 112($a0)
+    sw $zero, 116($a0)
+    sw $zero, 120($a0)
+    sw $zero, 124($a0)
+    lui $a1, 1
+#ifdef MACHINE_msim
+    /* Read dorder value */
+    la $k0, MSIM_DORDER_ADDRESS
+    lw $k1, ($k0)
+    /* If we are not running on BSP
+       then end in an infinite loop  */
+    beq $k1, $zero, bsp
     nop
+    /* Record CPU presence */
+    sll $a2, $k1, 2
+    addu $a2, $a2, $a0
+    sw $a1, ($a2)
+    loop:
+        j loop
+        nop
+#endif
+    bsp:
+        /* Record CPU presence */
+        sw $a1, ($a0)
+        /* Setup initial stack */
+        la $sp, INITIAL_STACK
+        j bootstrap
+        nop

 /branches/dynload/boot/arch/mips32/loader/main.c
 ,6 → 28,7
 #include "main.h"
 #include <printf.h>
+#include <align.h>
 #include <macros.h>
 #include "msim.h"
 #include "asm.h"
 ,9 → 74,10
         printf(" %L: %s image (size %d bytes)\n", components[i].start, components[i].name, components[i].size);
     printf("\nCopying components\n");
     unsigned int top = 0;
     bootinfo.cnt = 0;
-    for (i = 0; i < COMPONENTS; i++) {
+    for (i = 0; i < min(COMPONENTS, TASKMAP_MAX_RECORDS); i++) {
         printf(" %s...", components[i].name);
         top = ALIGN_UP(top, PAGE_SIZE);
         memcpy(((void *) KERNEL_VIRTUAL_ADDRESS) + top, components[i].start, components[i].size);
 ,6 → 90,13
         printf("done.\n");
     }
+    unsigned int *cpumap = (unsigned int *) CPUMAP;
+    bootinfo.cpumap = 0;
+    for (i = 0; i < CPUMAP_MAX_RECORDS; i++) {
+        if (cpumap[i] != 0)
+            bootinfo.cpumap |= (1 << i);
+    }
     printf("\nBooting the kernel...\n");
-    jump_to_kernel((void *) KERNEL_VIRTUAL_ADDRESS, &bootinfo, sizeof(bootinfo));
+    jump_to_kernel((void *) KERNEL_VIRTUAL_ADDRESS, &bootinfo);
 }

 /branches/dynload/boot/arch/mips32/loader/asm.h
 ,11 → 29,11
 #ifndef BOOT_mips32_ASM_H_
 #define BOOT_mips32_ASM_H_
-#define PAGE_SIZE 16384
-#define PAGE_WIDTH 14
+#define PAGE_SIZE   16384
+#define PAGE_WIDTH  14
-#define memcpy(dst, src, cnt)   __builtin_memcpy((dst), (src), (cnt))
+#define memcpy(dst, src, cnt)  __builtin_memcpy((dst), (src), (cnt))
-void jump_to_kernel(void *entry, void *bootinfo, unsigned int bootinfo_size) __attribute__((noreturn));
+void jump_to_kernel(void *entry, void *bootinfo) __attribute__((noreturn));
 #endif

 /branches/dynload/boot/arch/mips32/loader/main.h
 ,15 → 29,15
 #ifndef BOOT_mips32_MAIN_H_
 #define BOOT_mips32_MAIN_H_
-/** Align to the nearest higher address.
- *
- * @param addr  Address or size to be aligned.
- * @param align Size of alignment, must be power of 2.
- */
-#define ALIGN_UP(addr, align) (((addr) + ((align) - 1)) & ~((align) - 1))
+#define CPUMAP               0x80001000
+#define INITIAL_STACK        0x80002000
+#define MSIM_DORDER_ADDRESS  0xb0000004
-#define TASKMAP_MAX_RECORDS 32
+#define TASKMAP_MAX_RECORDS  32
+#define CPUMAP_MAX_RECORDS   32
+#ifndef __ASM__
 typedef struct {
     void *addr;
     unsigned int size;
 ,6 → 44,7
 } task_t;
 typedef struct {
+    unsigned int cpumap;
     unsigned int cnt;
     task_t tasks[TASKMAP_MAX_RECORDS];
 } bootinfo_t;
 ,3 → 53,5
 extern void bootstrap(void);
 #endif
+#endif

 /branches/dynload/Makefile
 ,20 → 29,17
 ## Include configuration
 #
--include Makefile.config
+.PHONY: all config distclean clean cscope
-.PHONY: all build config distclean clean cscope
-all:
-    tools/config.py HelenOS.config default
-    $(MAKE) -C . build
-build: Makefile.config config.h config.defs
+all: Makefile.config config.h config.defs
     $(MAKE) -C kernel
     $(MAKE) -C uspace
     $(MAKE) -C boot
-config: HelenOS.config
+Makefile.config config.h config.defs: HelenOS.config
+    tools/config.py HelenOS.config default
+config:
     tools/config.py HelenOS.config
 distclean: clean

Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 4342 → Rev 4343