WebSVN – HelenOS – Path Comparison – / – /branches/network/uspace/srv Rev 4077 and /branches/network/uspace/srv Rev 4153

Ignore whitespace Rev 4077 → Rev 4153

/branches/network/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/network/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/network/uspace/srv/kbd/ctl/pc.c
 ,0 → 1,231
+/*
+ * 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>
+#include <gsp.h>
+enum dec_state {
+    ds_s,
+    ds_e
+};
+static enum dec_state ds;
+static int scanmap_simple[] = {
+    [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,
+    [0x46] = KC_SCROLL_LOCK,
+    [0x1c] = KC_ENTER,
+    [0x45] = KC_NUM_LOCK,
+    [0x37] = KC_NTIMES,
+    [0x4a] = KC_NMINUS,
+    [0x4e] = KC_NPLUS,
+    [0x47] = KC_N7,
+    [0x48] = KC_N8,
+    [0x49] = KC_N9,
+    [0x4b] = KC_N4,
+    [0x4c] = KC_N5,
+    [0x4d] = KC_N6,
+    [0x4f] = KC_N1,
+    [0x50] = KC_N2,
+    [0x51] = KC_N3,
+    [0x52] = KC_N0,
+    [0x53] = KC_NPERIOD
+};
+static int scanmap_e0[] = {
+    [0x38] = KC_RALT,
+    [0x1d] = KC_RSHIFT,
+    [0x37] = KC_PRTSCR,
+    [0x52] = KC_INSERT,
+    [0x47] = KC_HOME,
+    [0x49] = KC_PAGE_UP,
+    [0x53] = KC_DELETE,
+    [0x4f] = KC_END,
+    [0x51] = KC_PAGE_DOWN,
+    [0x48] = KC_UP,
+    [0x4b] = KC_LEFT,
+    [0x50] = KC_DOWN,
+    [0x4d] = KC_RIGHT,
+    [0x35] = KC_NSLASH,
+    [0x1c] = KC_NENTER
+};
+int kbd_ctl_init(void)
+{
+    ds = ds_s;
+    return 0;
+}
+void kbd_ctl_parse_scancode(int scancode)
+{
+    kbd_ev_type_t type;
+    unsigned int key;
+    int *map;
+    size_t map_length;
+    if (scancode == 0xe0) {
+        ds = ds_e;
+        return;
+    }
+    switch (ds) {
+    case ds_s:
+        map = scanmap_simple;
+        map_length = sizeof(scanmap_simple) / sizeof(int);
+        break;
+    case ds_e:
+        map = scanmap_e0;
+        map_length = sizeof(scanmap_e0) / sizeof(int);
+        break;
+    }
+    ds = ds_s;
+    if (scancode & 0x80) {
+        scancode &= ~0x80;
+        type = KE_RELEASE;
+    } else {
+        type = KE_PRESS;
+    }
+    if (scancode < 0 || scancode >= map_length)
+        return;
+    key = map[scancode];
+    if (key != 0)
+        kbd_push_ev(type, key);
+}
+/**
+ * @}
+ */

 /branches/network/uspace/srv/kbd/ctl/stty.c
 ,0 → 1,229
+/*
+ * 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>
+#include <gsp.h>
+#include <stroke.h>
+/** Scancode parser */
+static gsp_t sp;
+/** Current parser state */
+static int ds;
+#include <stdio.h>
+int seq_defs[] = {
+    /* Not shifted */
+,  KC_BACKTICK,    0x60, GSP_END,
+,  KC_1,       0x31, GSP_END,
+,  KC_2,       0x32, GSP_END,
+,  KC_3,       0x33, GSP_END,
+,  KC_4,       0x34, GSP_END,
+,  KC_5,       0x35, GSP_END,
+,  KC_6,       0x36, GSP_END,
+,  KC_7,       0x37, GSP_END,
+,  KC_8,       0x38, GSP_END,
+,  KC_9,       0x39, GSP_END,
+,  KC_0,       0x30, GSP_END,
+,  KC_MINUS,   0x2d, GSP_END,
+,  KC_EQUALS,  0x3d, GSP_END,
+,  KC_BACKSPACE,   0x08, GSP_END,
+,  KC_TAB,     0x09, GSP_END,
+,  KC_Q,       0x71, GSP_END,
+,  KC_W,       0x77, GSP_END,
+,  KC_E,       0x65, GSP_END,
+,  KC_R,       0x72, GSP_END,
+,  KC_T,       0x74, GSP_END,
+,  KC_Y,       0x79, GSP_END,
+,  KC_U,       0x75, GSP_END,
+,  KC_I,       0x69, GSP_END,
+,  KC_O,       0x6f, GSP_END,
+,  KC_P,       0x70, GSP_END,
+,  KC_LBRACKET,    0x5b, GSP_END,
+,  KC_RBRACKET,    0x5d, GSP_END,
+,  KC_A,       0x61, GSP_END,
+,  KC_S,       0x73, GSP_END,
+,  KC_D,       0x64, GSP_END,
+,  KC_F,       0x66, GSP_END,
+,  KC_G,       0x67, GSP_END,
+,  KC_H,       0x68, GSP_END,
+,  KC_J,       0x6a, GSP_END,
+,  KC_K,       0x6b, GSP_END,
+,  KC_L,       0x6c, GSP_END,
+,  KC_SEMICOLON,   0x3b, GSP_END,
+,  KC_QUOTE,   0x27, GSP_END,
+,  KC_BACKSLASH,   0x5c, GSP_END,
+,  KC_Z,       0x7a, GSP_END,
+,  KC_X,       0x78, GSP_END,
+,  KC_C,       0x63, GSP_END,
+,  KC_V,       0x76, GSP_END,
+,  KC_B,       0x62, GSP_END,
+,  KC_N,       0x6e, GSP_END,
+,  KC_M,       0x6d, GSP_END,
+,  KC_COMMA,   0x2c, GSP_END,
+,  KC_PERIOD,  0x2e, GSP_END,
+,  KC_SLASH,   0x2f, GSP_END,
+    /* Shifted */
+    KM_SHIFT,   KC_BACKTICK,    0x7e, GSP_END,
+    KM_SHIFT,   KC_1,       0x21, GSP_END,
+    KM_SHIFT,   KC_2,       0x40, GSP_END,
+    KM_SHIFT,   KC_3,       0x23, GSP_END,
+    KM_SHIFT,   KC_4,       0x24, GSP_END,
+    KM_SHIFT,   KC_5,       0x25, GSP_END,
+    KM_SHIFT,   KC_6,       0x5e, GSP_END,
+    KM_SHIFT,   KC_7,       0x26, GSP_END,
+    KM_SHIFT,   KC_8,       0x2a, GSP_END,
+    KM_SHIFT,   KC_9,       0x28, GSP_END,
+    KM_SHIFT,   KC_0,       0x29, GSP_END,
+    KM_SHIFT,   KC_MINUS,   0x5f, GSP_END,
+    KM_SHIFT,   KC_EQUALS,  0x2b, GSP_END,
+    KM_SHIFT,   KC_Q,       0x51, GSP_END,
+    KM_SHIFT,   KC_W,       0x57, GSP_END,
+    KM_SHIFT,   KC_E,       0x45, GSP_END,
+    KM_SHIFT,   KC_R,       0x52, GSP_END,
+    KM_SHIFT,   KC_T,       0x54, GSP_END,
+    KM_SHIFT,   KC_Y,       0x59, GSP_END,
+    KM_SHIFT,   KC_U,       0x55, GSP_END,
+    KM_SHIFT,   KC_I,       0x49, GSP_END,
+    KM_SHIFT,   KC_O,       0x4f, GSP_END,
+    KM_SHIFT,   KC_P,       0x50, GSP_END,
+    KM_SHIFT,   KC_LBRACKET,    0x7b, GSP_END,
+    KM_SHIFT,   KC_RBRACKET,    0x7d, GSP_END,
+    KM_SHIFT,   KC_A,       0x41, GSP_END,
+    KM_SHIFT,   KC_S,       0x53, GSP_END,
+    KM_SHIFT,   KC_D,       0x44, GSP_END,
+    KM_SHIFT,   KC_F,       0x46, GSP_END,
+    KM_SHIFT,   KC_G,       0x47, GSP_END,
+    KM_SHIFT,   KC_H,       0x48, GSP_END,
+    KM_SHIFT,   KC_J,       0x4a, GSP_END,
+    KM_SHIFT,   KC_K,       0x4b, GSP_END,
+    KM_SHIFT,   KC_L,       0x4c, GSP_END,
+    KM_SHIFT,   KC_SEMICOLON,   0x3a, GSP_END,
+    KM_SHIFT,   KC_QUOTE,   0x22, GSP_END,
+    KM_SHIFT,   KC_BACKSLASH,   0x7c, GSP_END,
+    KM_SHIFT,   KC_Z,       0x5a, GSP_END,
+    KM_SHIFT,   KC_X,       0x58, GSP_END,
+    KM_SHIFT,   KC_C,       0x43, GSP_END,
+    KM_SHIFT,   KC_V,       0x56, GSP_END,
+    KM_SHIFT,   KC_B,       0x42, GSP_END,
+    KM_SHIFT,   KC_N,       0x4e, GSP_END,
+    KM_SHIFT,   KC_M,       0x4d, GSP_END,
+    KM_SHIFT,   KC_COMMA,   0x3c, GSP_END,
+    KM_SHIFT,   KC_PERIOD,  0x3e, GSP_END,
+    KM_SHIFT,   KC_SLASH,   0x3f, GSP_END,
+    /* ... */
+,  KC_SPACE,   0x20, GSP_END,
+,  KC_ENTER,   0x0a, GSP_END,
+,  KC_ENTER,   0x0d, GSP_END,
+,  KC_ESCAPE,  0x1b, 0x1b, GSP_END,
+,  KC_F1,      0x1b, 0x4f, 0x50, GSP_END,
+,  KC_F2,      0x1b, 0x4f, 0x51, GSP_END,
+,  KC_F3,      0x1b, 0x4f, 0x52, GSP_END,
+,  KC_F4,      0x1b, 0x4f, 0x53, GSP_END,
+,  KC_F5,      0x1b, 0x5b, 0x31, 0x35, 0x7e, GSP_END,
+,  KC_F6,      0x1b, 0x5b, 0x31, 0x37, 0x7e, GSP_END,
+,  KC_F7,      0x1b, 0x5b, 0x31, 0x38, 0x7e, GSP_END,
+,  KC_F8,      0x1b, 0x5b, 0x31, 0x39, 0x7e, GSP_END,
+,  KC_F9,      0x1b, 0x5b, 0x32, 0x30, 0x7e, GSP_END,
+,  KC_F10,     0x1b, 0x5b, 0x32, 0x31, 0x7e, GSP_END,
+,  KC_F11,     0x1b, 0x5b, 0x32, 0x33, 0x7e, GSP_END,
+,  KC_F12,     0x1b, 0x5b, 0x32, 0x34, 0x7e, GSP_END,
+,  KC_INSERT,  0x1b, 0x5b, 0x32, 0x7e, GSP_END,
+,  KC_HOME,    0x1b, 0x5b, 0x48, GSP_END,
+,  KC_PAGE_UP, 0x1b, 0x5b, 0x35, 0x7e, GSP_END,
+,  KC_DELETE,  0x1b, 0x5b, 0x33, 0x7e, GSP_END,
+,  KC_END,     0x1b, 0x5b, 0x46, GSP_END,
+,  KC_PAGE_DOWN,   0x1b, 0x5b, 0x36, 0x7e, GSP_END,
+,  KC_UP,      0x1b, 0x5b, 0x41, GSP_END,
+,  KC_LEFT,    0x1b, 0x5b, 0x44, GSP_END,
+,  KC_DOWN,    0x1b, 0x5b, 0x42, GSP_END,
+,  KC_RIGHT,   0x1b, 0x5b, 0x43, GSP_END,
+,  0
+};
+int kbd_ctl_init(void)
+{
+    ds = 0;
+    gsp_init(&sp);
+    return gsp_insert_defs(&sp, seq_defs);
+}
+void kbd_ctl_parse_scancode(int scancode)
+{
+    unsigned mods, key;
+    ds = gsp_step(&sp, ds, scancode, &mods, &key);
+    if (key != 0) {
+        stroke_sim(mods, key);
+    }
+}
+/**
+ * @}
+ */

 /branches/network/uspace/srv/kbd/ctl/sun.c
 ,0 → 1,209
+/*
+ * 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[];
+int kbd_ctl_init(void)
+{
+    return 0;
+}
+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);
+}
+/** 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/network/uspace/srv/kbd/ctl/gxe_fb.c
 ,0 → 1,229
+/*
+ * 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>
+#include <gsp.h>
+#include <stroke.h>
+/** Scancode parser */
+static gsp_t sp;
+/** Current parser state */
+static int ds;
+#include <stdio.h>
+int seq_defs[] = {
+    /* Not shifted */
+,  KC_BACKTICK,    0x60, GSP_END,
+,  KC_1,       0x31, GSP_END,
+,  KC_2,       0x32, GSP_END,
+,  KC_3,       0x33, GSP_END,
+,  KC_4,       0x34, GSP_END,
+,  KC_5,       0x35, GSP_END,
+,  KC_6,       0x36, GSP_END,
+,  KC_7,       0x37, GSP_END,
+,  KC_8,       0x38, GSP_END,
+,  KC_9,       0x39, GSP_END,
+,  KC_0,       0x30, GSP_END,
+,  KC_MINUS,   0x2d, GSP_END,
+,  KC_EQUALS,  0x3d, GSP_END,
+,  KC_BACKSPACE,   0x08, GSP_END,
+,  KC_TAB,     0x09, GSP_END,
+,  KC_Q,       0x71, GSP_END,
+,  KC_W,       0x77, GSP_END,
+,  KC_E,       0x65, GSP_END,
+,  KC_R,       0x72, GSP_END,
+,  KC_T,       0x74, GSP_END,
+,  KC_Y,       0x79, GSP_END,
+,  KC_U,       0x75, GSP_END,
+,  KC_I,       0x69, GSP_END,
+,  KC_O,       0x6f, GSP_END,
+,  KC_P,       0x70, GSP_END,
+,  KC_LBRACKET,    0x5b, GSP_END,
+,  KC_RBRACKET,    0x5d, GSP_END,
+,  KC_A,       0x61, GSP_END,
+,  KC_S,       0x73, GSP_END,
+,  KC_D,       0x64, GSP_END,
+,  KC_F,       0x66, GSP_END,
+,  KC_G,       0x67, GSP_END,
+,  KC_H,       0x68, GSP_END,
+,  KC_J,       0x6a, GSP_END,
+,  KC_K,       0x6b, GSP_END,
+,  KC_L,       0x6c, GSP_END,
+,  KC_SEMICOLON,   0x3b, GSP_END,
+,  KC_QUOTE,   0x27, GSP_END,
+,  KC_BACKSLASH,   0x5c, GSP_END,
+,  KC_Z,       0x7a, GSP_END,
+,  KC_X,       0x78, GSP_END,
+,  KC_C,       0x63, GSP_END,
+,  KC_V,       0x76, GSP_END,
+,  KC_B,       0x62, GSP_END,
+,  KC_N,       0x6e, GSP_END,
+,  KC_M,       0x6d, GSP_END,
+,  KC_COMMA,   0x2c, GSP_END,
+,  KC_PERIOD,  0x2e, GSP_END,
+,  KC_SLASH,   0x2f, GSP_END,
+    /* Shifted */
+    KM_SHIFT,   KC_BACKTICK,    0x7e, GSP_END,
+    KM_SHIFT,   KC_1,       0x21, GSP_END,
+    KM_SHIFT,   KC_2,       0x40, GSP_END,
+    KM_SHIFT,   KC_3,       0x23, GSP_END,
+    KM_SHIFT,   KC_4,       0x24, GSP_END,
+    KM_SHIFT,   KC_5,       0x25, GSP_END,
+    KM_SHIFT,   KC_6,       0x5e, GSP_END,
+    KM_SHIFT,   KC_7,       0x26, GSP_END,
+    KM_SHIFT,   KC_8,       0x2a, GSP_END,
+    KM_SHIFT,   KC_9,       0x28, GSP_END,
+    KM_SHIFT,   KC_0,       0x29, GSP_END,
+    KM_SHIFT,   KC_MINUS,   0x5f, GSP_END,
+    KM_SHIFT,   KC_EQUALS,  0x2b, GSP_END,
+    KM_SHIFT,   KC_Q,       0x51, GSP_END,
+    KM_SHIFT,   KC_W,       0x57, GSP_END,
+    KM_SHIFT,   KC_E,       0x45, GSP_END,
+    KM_SHIFT,   KC_R,       0x52, GSP_END,
+    KM_SHIFT,   KC_T,       0x54, GSP_END,
+    KM_SHIFT,   KC_Y,       0x59, GSP_END,
+    KM_SHIFT,   KC_U,       0x55, GSP_END,
+    KM_SHIFT,   KC_I,       0x49, GSP_END,
+    KM_SHIFT,   KC_O,       0x4f, GSP_END,
+    KM_SHIFT,   KC_P,       0x50, GSP_END,
+    KM_SHIFT,   KC_LBRACKET,    0x7b, GSP_END,
+    KM_SHIFT,   KC_RBRACKET,    0x7d, GSP_END,
+    KM_SHIFT,   KC_A,       0x41, GSP_END,
+    KM_SHIFT,   KC_S,       0x53, GSP_END,
+    KM_SHIFT,   KC_D,       0x44, GSP_END,
+    KM_SHIFT,   KC_F,       0x46, GSP_END,
+    KM_SHIFT,   KC_G,       0x47, GSP_END,
+    KM_SHIFT,   KC_H,       0x48, GSP_END,
+    KM_SHIFT,   KC_J,       0x4a, GSP_END,
+    KM_SHIFT,   KC_K,       0x4b, GSP_END,
+    KM_SHIFT,   KC_L,       0x4c, GSP_END,
+    KM_SHIFT,   KC_SEMICOLON,   0x3a, GSP_END,
+    KM_SHIFT,   KC_QUOTE,   0x22, GSP_END,
+    KM_SHIFT,   KC_BACKSLASH,   0x7c, GSP_END,
+    KM_SHIFT,   KC_Z,       0x5a, GSP_END,
+    KM_SHIFT,   KC_X,       0x58, GSP_END,
+    KM_SHIFT,   KC_C,       0x43, GSP_END,
+    KM_SHIFT,   KC_V,       0x56, GSP_END,
+    KM_SHIFT,   KC_B,       0x42, GSP_END,
+    KM_SHIFT,   KC_N,       0x4e, GSP_END,
+    KM_SHIFT,   KC_M,       0x4d, GSP_END,
+    KM_SHIFT,   KC_COMMA,   0x3c, GSP_END,
+    KM_SHIFT,   KC_PERIOD,  0x3e, GSP_END,
+    KM_SHIFT,   KC_SLASH,   0x3f, GSP_END,
+    /* ... */
+,  KC_SPACE,   0x20, GSP_END,
+,  KC_ENTER,   0x0a, GSP_END,
+,  KC_ENTER,   0x0d, GSP_END,
+,  KC_ESCAPE,  0x1b, 0x1b, GSP_END,
+,  KC_F1,      0x1b, 0x5b, 0x4f, 0x50, GSP_END,
+,  KC_F2,      0x1b, 0x5b, 0x4f, 0x51, GSP_END,
+,  KC_F3,      0x1b, 0x5b, 0x4f, 0x52, GSP_END,
+,  KC_F4,      0x1b, 0x5b, 0x4f, 0x53, GSP_END,
+,  KC_F5,      0x1b, 0x5b, 0x31, 0x35, GSP_END,
+,  KC_F6,      0x1b, 0x5b, 0x31, 0x37, GSP_END,
+,  KC_F7,      0x1b, 0x5b, 0x31, 0x38, GSP_END,
+,  KC_F8,      0x1b, 0x5b, 0x31, 0x39, GSP_END,
+,  KC_F9,      0x1b, 0x5b, 0x32, 0x38, GSP_END,
+,  KC_F10,     0x1b, 0x5b, 0x32, 0x39, GSP_END,
+,  KC_F11,     0x1b, 0x5b, 0x32, 0x33, GSP_END,
+,  KC_F12,     0x1b, 0x5b, 0x32, 0x34, GSP_END,
+,  KC_INSERT,  0x1b, 0x5b, 0x32, 0x7e, GSP_END,
+,  KC_HOME,    0x1b, 0x5b, 0x48, GSP_END,
+,  KC_PAGE_UP, 0x1b, 0x5b, 0x35, 0x7e, GSP_END,
+,  KC_DELETE,  0x1b, 0x5b, 0x33, 0x7e, GSP_END,
+,  KC_END,     0x1b, 0x5b, 0x46, GSP_END,
+,  KC_PAGE_DOWN,   0x1b, 0x5b, 0x36, 0x7e, GSP_END,
+,  KC_UP,      0x1b, 0x5b, 0x41, GSP_END,
+,  KC_LEFT,    0x1b, 0x5b, 0x44, GSP_END,
+,  KC_DOWN,    0x1b, 0x5b, 0x42, GSP_END,
+,  KC_RIGHT,   0x1b, 0x5b, 0x43, GSP_END,
+,  0
+};
+int kbd_ctl_init(void)
+{
+    ds = 0;
+    gsp_init(&sp);
+    return gsp_insert_defs(&sp, seq_defs);
+}
+void kbd_ctl_parse_scancode(int scancode)
+{
+    unsigned mods, key;
+    ds = gsp_step(&sp, ds, scancode, &mods, &key);
+    if (key != 0) {
+        stroke_sim(mods, key);
+    }
+}
+/**
+ * @}
+ */

 /branches/network/uspace/srv/kbd/include/gsp.h
 ,0 → 1,84
+/*
+ * 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   Generic scancode parser.
+ * @ingroup  kbd
+ * @{
+ */
+/** @file
+ */
+#ifndef KBD_GSP_H_
+#define KBD_GSP_H_
+#include <libadt/hash_table.h>
+enum {
+    GSP_END     = -1,   /**< Terminates a sequence. */
+    GSP_DEFAULT = -2    /**< Wildcard, catches unhandled cases. */
+};
+/** Scancode parser description */
+typedef struct {
+    /** Transition table, (state, input) -> (state, output) */
+    hash_table_t trans;
+    /** Number of states */
+    int states;
+} gsp_t;
+/** Scancode parser transition. */
+typedef struct {
+    link_t link;        /**< Link to hash table in @c gsp_t */
+    /* Preconditions */
+    int old_state;      /**< State before transition */
+    int input;      /**< Input symbol (scancode) */
+    /* Effects */
+    int new_state;      /**< State after transition */
+    /* Output emitted during transition */
+    unsigned out_mods;  /**< Modifier to emit */
+    unsigned out_key;   /**< Keycode to emit */
+} gsp_trans_t;
+extern void gsp_init(gsp_t *);
+extern int gsp_insert_defs(gsp_t *, const int *);
+extern int gsp_insert_seq(gsp_t *, const int *, unsigned, unsigned);
+extern int gsp_step(gsp_t *, int, int, unsigned *, unsigned *);
+#endif
+/**
+ * @}
+ */

 /branches/network/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/network/uspace/srv/kbd/include/kbd.h
 ,10 → 39,18
 #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 int cir_service;
+extern int cir_phone;
+extern void kbd_push_scancode(int);
+extern void kbd_push_ev(int, unsigned int);
 #endif
 /**

 /branches/network/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/network/uspace/srv/kbd/include/kbd_ctl.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_CTL_H_
+#define KBD_CTL_H_
+extern void kbd_ctl_parse_scancode(int);
+extern int kbd_ctl_init(void);
+#endif
+/**
+ * @}
+ */

 /branches/network/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/network/uspace/srv/kbd/include/stroke.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   Generic scancode parser.
+ * @ingroup  kbd
+ * @{
+ */
+/** @file
+ */
+#ifndef KBD_STROKE_H_
+#define KBD_STROKE_H_
+extern void stroke_sim(unsigned, unsigned);
+#endif
+/**
+ * @}
+ */

 /branches/network/uspace/srv/kbd/port/gxemul.c
 ,0 → 1,87
+/*
+ * 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>
+#include <ddi.h>
+static irq_cmd_t gxemul_cmds[] = {
+    {
+        .cmd = CMD_PIO_READ_8,
+        .addr = (void *) 0,     /* will be patched in run-time */
+        .dstarg = 2,
+    },
+    {
+        .cmd = CMD_ACCEPT
+    }
+};
+static irq_code_t gxemul_kbd = {
+    sizeof(gxemul_cmds) / sizeof(irq_cmd_t),
+    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"), device_assign_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/network/uspace/srv/kbd/port/ns16550.c
 ,0 → 1,115
+/*
+ * 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. */
+#define LSR_DATA_READY  0x01
+static irq_cmd_t ns16550_cmds[] = {
+    {
+        .cmd = CMD_PIO_READ_8,
+        .addr = (void *) 0, /* will be patched in run-time */
+        .dstarg = 1
+    },
+    {
+        .cmd = CMD_BTEST,
+        .value = LSR_DATA_READY,
+        .srcarg = 1,
+        .dstarg = 3
+    },
+    {
+        .cmd = CMD_PREDICATE,
+        .value = 2,
+        .srcarg = 3
+    },
+    {
+        .cmd = CMD_PIO_READ_8,
+        .addr = (void *) 0, /* will be patched in run-time */
+        .dstarg = 2
+    },
+    {
+        .cmd = CMD_ACCEPT
+    }
+};
+irq_code_t ns16550_kbd = {
+    sizeof(ns16550_cmds) / sizeof(irq_cmd_t),
+    ns16550_cmds
+};
+static void ns16550_irq_handler(ipc_callid_t iid, ipc_call_t *call);
+static uintptr_t ns16550_physical;
+static uintptr_t ns16550_kernel;
+int kbd_port_init(void)
+{
+    void *vaddr;
+    async_set_interrupt_received(ns16550_irq_handler);
+    ns16550_physical = sysinfo_value("kbd.address.physical");
+    ns16550_kernel = sysinfo_value("kbd.address.kernel");
+    ns16550_kbd.cmds[0].addr = (void *) (ns16550_kernel + LSR_REG);
+    ns16550_kbd.cmds[3].addr = (void *) (ns16550_kernel + RBR_REG);
+    ipc_register_irq(sysinfo_value("kbd.inr"), device_assign_devno(),
+, &ns16550_kbd);
+    return pio_enable((void *) ns16550_physical, 8, &vaddr);
+}
+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/network/uspace/srv/kbd/port/msim.c
 ,0 → 1,92
+/*
+ * 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>
+#include <ddi.h>
+irq_cmd_t msim_cmds[] = {
+    {
+        .cmd = CMD_PIO_READ_8,
+        .addr = (void *) 0, /* will be patched in run-time */
+        .dstarg = 2
+    },
+    {
+        .cmd = CMD_ACCEPT
+    }
+};
+irq_code_t msim_kbd = {
+    sizeof(msim_cmds) / sizeof(irq_cmd_t),
+    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"), device_assign_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/network/uspace/srv/kbd/port/i8042.c
 ,0 → 1,169
+/*
+ * 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 <ddi.h>
+#include <libarch/ddi.h>
+#include <ipc/ipc.h>
+#include <async.h>
+#include <unistd.h>
+#include <sysinfo.h>
+#include <kbd_port.h>
+#include <kbd.h>
+#include <ddi.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[] = {
+    {
+        .cmd = CMD_PIO_READ_8,
+        .addr = NULL,   /* will be patched in run-time */
+        .dstarg = 1
+    },
+    {
+        .cmd = CMD_BTEST,
+        .value = i8042_OUTPUT_FULL,
+        .srcarg = 1,
+        .dstarg = 3
+    },
+    {
+        .cmd = CMD_PREDICATE,
+        .value = 2,
+        .srcarg = 3
+    },
+    {
+        .cmd = CMD_PIO_READ_8,
+        .addr = NULL,   /* will be patched in run-time */
+        .dstarg = 2
+    },
+    {
+        .cmd = CMD_ACCEPT
+    }
+};
+static irq_code_t i8042_kbd = {
+    sizeof(i8042_cmds) / sizeof(irq_cmd_t),
+    i8042_cmds
+};
+static uintptr_t i8042_physical;
+static uintptr_t i8042_kernel;
+static i8042_t * i8042;
+static void wait_ready(void) {
+    while (pio_read_8(&i8042->status) & i8042_INPUT_FULL)
+        ;
+}
+static void i8042_irq_handler(ipc_callid_t iid, ipc_call_t *call);
+int kbd_port_init(void)
+{
+    int mouseenabled = 0;
+    void *vaddr;
+    i8042_physical = sysinfo_value("kbd.address.physical");
+    i8042_kernel = sysinfo_value("kbd.address.kernel");
+    if (pio_enable((void *) i8042_physical, sizeof(i8042_t), &vaddr) != 0)
+        return -1;
+    i8042 = vaddr;
+    async_set_interrupt_received(i8042_irq_handler);
+    /* Disable kbd, enable mouse */
+    pio_write_8(&i8042->status, i8042_CMD_KBD);
+    wait_ready();
+    pio_write_8(&i8042->status, i8042_CMD_KBD);
+    wait_ready();
+    pio_write_8(&i8042->data, i8042_KBD_DISABLE);
+    wait_ready();
+    /* Flush all current IO */
+    while (pio_read_8(&i8042->status) & i8042_OUTPUT_FULL)
+        (void) pio_read_8(&i8042->data);
+    /* Enable kbd */
+    i8042_kbd.cmds[0].addr = &((i8042_t *) i8042_kernel)->status;
+    i8042_kbd.cmds[3].addr = &((i8042_t *) i8042_kernel)->data;
+    ipc_register_irq(sysinfo_value("kbd.inr"), device_assign_devno(), 0, &i8042_kbd);
+    int newcontrol = i8042_KBD_IE | i8042_KBD_TRANSLATE;
+    if (mouseenabled)
+        newcontrol |= i8042_MOUSE_IE;
+    pio_write_8(&i8042->status, i8042_CMD_KBD);
+    wait_ready();
+    pio_write_8(&i8042->data, 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;
+    int scan_code = IPC_GET_ARG2(*call);
+    kbd_push_scancode(scan_code);
+    return;
+}
+/**
+ * @}
+ */

 /branches/network/uspace/srv/kbd/port/z8530.c
 ,0 → 1,108
+/*
+ * 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 <ipc/bus.h>
+#include <async.h>
+#include <sysinfo.h>
+#include <kbd.h>
+#include <kbd_port.h>
+#include <sys/types.h>
+#include <ddi.h>
+#define CHAN_A_STATUS   4
+#define CHAN_A_DATA 6
+#define RR0_RCA 1
+static irq_cmd_t z8530_cmds[] = {
+    {
+        .cmd = CMD_PIO_READ_8,
+        .addr = (void *) 0, /* will be patched in run-time */
+        .dstarg = 1
+    },
+    {
+        .cmd = CMD_BTEST,
+        .value = RR0_RCA,
+        .srcarg = 1,
+        .dstarg = 3
+    },
+    {
+        .cmd = CMD_PREDICATE,
+        .value = 2,
+        .srcarg = 3
+    },
+    {
+        .cmd = CMD_PIO_READ_8,
+        .addr = (void *) 0, /* will be patched in run-time */
+        .dstarg = 2
+    },
+    {
+        .cmd = CMD_ACCEPT
+    }
+};
+irq_code_t z8530_kbd = {
+    sizeof(z8530_cmds) / sizeof(irq_cmd_t),
+    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.kernel") +
+        CHAN_A_STATUS;
+    z8530_cmds[3].addr = (void *) sysinfo_value("kbd.address.kernel") +
+        CHAN_A_DATA;
+    ipc_register_irq(sysinfo_value("kbd.inr"), device_assign_devno(),
+        sysinfo_value("kbd.inr"), &z8530_kbd);
+    return 0;
+}
+static void z8530_irq_handler(ipc_callid_t iid, ipc_call_t *call)
+{
+    int scan_code = IPC_GET_ARG2(*call);
+    kbd_push_scancode(scan_code);
+    if (cir_service)
+        async_msg_1(cir_phone, BUS_CLEAR_INTERRUPT,
+            IPC_GET_METHOD(*call));
+}
+/** @}
+ */

 /branches/network/uspace/srv/kbd/port/ski.c
 ,0 → 1,110
+/*
+ * Copyright (c) 2005 Jakub Jermar
+ * 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
+ * @ingroup  kbd
+ * @{
+ */
+/** @file
+ * @brief   Ski console keyboard port driver.
+ */
+#include <stdlib.h>
+#include <unistd.h>
+#include <kbd.h>
+#include <kbd_port.h>
+#include <sys/types.h>
+#include <thread.h>
+#define SKI_GETCHAR     21
+#define POLL_INTERVAL       10000
+static void *ski_thread_impl(void *arg);
+static int32_t ski_getchar(void);
+/** Initialize Ski port driver. */
+int kbd_port_init(void)
+{
+    thread_id_t tid;
+    int rc;
+    rc = thread_create(ski_thread_impl, NULL, "kbd_poll", &tid);
+    if (rc != 0) {
+        return rc;
+    }
+    return 0;
+}
+/** Thread to poll Ski for keypresses. */
+static void *ski_thread_impl(void *arg)
+{
+    int32_t c;
+    (void) arg;
+    while (1) {
+        while (1) {
+            c = ski_getchar();
+            if (c == 0)
+                break;
+            kbd_push_scancode(c);
+        }
+        usleep(POLL_INTERVAL);
+    }
+}
+/** Ask Ski if a key was pressed.
+ *
+ * Use SSC (Simulator System Call) to get character from the debug console.
+ * This call is non-blocking.
+ *
+ * @return ASCII code of pressed key or 0 if no key pressed.
+ */
+static int32_t ski_getchar(void)
+{
+    uint64_t ch;
+    asm volatile (
+        "mov r15 = %1\n"
+        "break 0x80000;;\n" /* modifies r8 */
+        "mov %0 = r8;;\n"
+        : "=r" (ch)
+        : "i" (SKI_GETCHAR)
+        : "r15", "r8"
+    );
+    return (int32_t) ch;
+}
+/** @}
+ */

 /branches/network/uspace/srv/kbd/port/sgcn.c
 ,0 → 1,164
+/*
+ * 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 <async.h>
+#include <kbd.h>
+#include <kbd_port.h>
+#include <sysinfo.h>
+#include <stdio.h>
+#include <thread.h>
+#define POLL_INTERVAL       10000
+/**
+ * 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;
+/* polling thread */
+static void *sgcn_thread_impl(void *arg);
+/**
+ * Initializes the SGCN driver.
+ * Maps the physical memory (SRAM) and creates the polling thread.
+ */
+int kbd_port_init(void)
+{
+    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");
+    thread_id_t tid;
+    int rc;
+    rc = thread_create(sgcn_thread_impl, NULL, "kbd_poll", &tid);
+    if (rc != 0) {
+        return rc;
+    }
+    return 0;
+}
+/**
+ * Handler of the "key pressed" event. Reads codes of all the pressed keys from
+ * the buffer.
+ */
+static void sgcn_key_pressed(void)
+{
+    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);
+    }
+}
+/**
+ * Thread to poll SGCN for keypresses.
+ */
+static void *sgcn_thread_impl(void *arg)
+{
+    (void) arg;
+    while (1) {
+        sgcn_key_pressed();
+        usleep(POLL_INTERVAL);
+    }
+}
+/** @}
+ */

 /branches/network/uspace/srv/kbd/port/i8042.h
 ,0 → 1,55
+/*
+ * 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 <libarch/ddi.h>
+#include <libarch/types.h>
+struct i8042 {
+    ioport8_t data;
+    uint8_t pad[3];
+    ioport8_t status;
+} __attribute__ ((packed));
+typedef struct i8042 i8042_t;
+#endif
+/**
+ * @}
+ */

 /branches/network/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/network/uspace/srv/kbd/genarch/stroke.c
 ,0 → 1,84
+/*
+ * 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
+ * @{
+ */
+/**
+ * @file
+ * @brief   Stroke simulator.
+ *
+ * When simulating a keyboard using a serial TTY we need to convert the
+ * recognized strokes (such as Shift-A) to sequences of key presses and
+ * releases (such as 'press Shift, press A, release A, release Shift').
+ */
+#include <stroke.h>
+#include <kbd.h>
+#include <kbd/kbd.h>
+#include <kbd/keycode.h>
+/** Correspondence between modifers and the modifier keycodes. */
+static unsigned int mods_keys[][2] = {
+    { KM_LSHIFT, KC_LSHIFT },
+    { 0, 0 }
+};
+/** Simulate keystroke using sequences of key presses and releases. */
+void stroke_sim(unsigned mod, unsigned key)
+{
+    int i;
+    /* Simulate modifier presses. */
+    i = 0;
+    while (mods_keys[i][0] != 0) {
+        if (mod & mods_keys[i][0]) {
+            kbd_push_ev(KE_PRESS, mods_keys[i][1]);
+        }
+        ++i;
+    }
+    /* Simulate key press and release. */
+    if (key != 0) {
+        kbd_push_ev(KE_PRESS, key);
+        kbd_push_ev(KE_RELEASE, key);
+    }
+    /* Simulate modifier releases. */
+    i = 0;
+    while (mods_keys[i][0] != 0) {
+        if (mod & mods_keys[i][0]) {
+            kbd_push_ev(KE_RELEASE, mods_keys[i][1]);
+        }
+        ++i;
+    }
+}
+/**
+ * @}
+ */

 /branches/network/uspace/srv/kbd/genarch/gsp.c
 ,0 → 1,288
+/*
+ * 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
+ * @ingroup  kbd
+ * @{
+ */
+/** @file
+ * @brief   Generic scancode parser.
+ *
+ * The scancode parser is a simple finite state machine. It is described
+ * using sequences of input symbols (scancodes) and the corresponding output
+ * value (mods, key pair). When the parser recognizes a sequence,
+ * it outputs the value and restarts. If a transition is undefined,
+ * the parser restarts, too.
+ *
+ * Apart from precise values, GSP_DEFAULT allows to catch general cases.
+ * I.e. if we knew that after 0x1b 0x4f there always follow two more
+ * scancodes, we can define (0x1b, 0x4f, GSP_DEFAULT, GSP_DEFAULT, GSP_END)
+ * with null output. This will force the parser to read the entire sequence,
+ * not leaving garbage on the input if it does not recognize the specific
+ * sequence.
+ */
+#include <gsp.h>
+#include <libadt/hash_table.h>
+#include <stdlib.h>
+#include <stdio.h>
+#define TRANS_TABLE_CHAINS 256
+/*
+ * Hash table operations for the transition function.
+ */
+static hash_index_t trans_op_hash(unsigned long key[]);
+static int trans_op_compare(unsigned long key[], hash_count_t keys,
+    link_t *item);
+static void trans_op_remove_callback(link_t *item);
+static hash_table_operations_t trans_ops = {
+    .hash = trans_op_hash,
+    .compare = trans_op_compare,
+    .remove_callback = trans_op_remove_callback
+};
+static gsp_trans_t *trans_lookup(gsp_t *p, int state, int input);
+static void trans_insert(gsp_t *p, gsp_trans_t *t);
+static gsp_trans_t *trans_new(void);
+/** Initialise scancode parser. */
+void gsp_init(gsp_t *p)
+{
+    p->states = 1;
+    hash_table_create(&p->trans, TRANS_TABLE_CHAINS, 2, &trans_ops);
+}
+/** Insert a series of definitions into the parser.
+ *
+ * @param p The parser.
+ * @param defs  Definition list. Each definition starts with two output values
+ *      (mods, key) and continues with a sequence of input values
+ *      terminated with GSP_END. The definition list is terminated
+ *      with two zeroes (0, 0) for output values.
+ */
+int gsp_insert_defs(gsp_t *p, const int *defs)
+{
+    unsigned mods, key;
+    const int *dp;
+    int rc;
+    dp = defs;
+    while (1) {
+        /* Read the output values. */
+        mods = *dp++;
+        key = *dp++;
+        if (key == 0) break;
+        /* Insert one sequence. */
+        rc = gsp_insert_seq(p, dp, mods, key);
+        if (rc != 0)
+            return rc;
+        /* Skip to the next definition. */
+        while (*dp != GSP_END)
+            ++dp;
+        ++dp;
+    }
+    return 0;
+}
+/** Insert one sequence into the parser.
+ *
+ * @param p The parser.
+ * @param seq   Sequence of input values terminated with GSP_END.
+ * @param mods  Corresponsing output value.
+ * @param key   Corresponsing output value.
+ */
+int gsp_insert_seq(gsp_t *p, const int *seq, unsigned mods, unsigned key)
+{
+    int state;
+    gsp_trans_t *t;
+    state = 0;
+    t = NULL;
+    /* Input sequence must be non-empty. */
+    if (*seq == GSP_END)
+        return -1;
+    while (*(seq + 1) != GSP_END) {
+        t = trans_lookup(p, state, *seq);
+        if (t == NULL) {
+            /* Create new state. */
+            t = trans_new();
+            t->old_state = state;
+            t->input = *seq;
+            t->new_state = p->states++;
+            t->out_mods = 0;
+            t->out_key = 0;
+            trans_insert(p, t);
+        }
+        state = t->new_state;
+        ++seq;
+    }
+    /* Process the last transition. */
+    t = trans_lookup(p, state, *seq);
+    if (t != NULL) {
+        exit(1);
+        return -1;  /* Conflicting definition. */
+    }
+    t = trans_new();
+    t->old_state = state;
+    t->input = *seq;
+    t->new_state = 0;
+    t->out_mods = mods;
+    t->out_key = key;
+    trans_insert(p, t);
+    return 0;
+}
+/** Compute one parser step.
+ *
+ * Computes the next state and output values for a given state and input.
+ * This handles everything including restarts and default branches.
+ *
+ * @param p     The parser.
+ * @param state     Old state.
+ * @param input     Input symbol (scancode).
+ * @param mods      Output value (modifier).
+ * @param key       Output value (key).
+ * @return      New state.
+ */
+int gsp_step(gsp_t *p, int state, int input, unsigned *mods, unsigned *key)
+{
+    gsp_trans_t *t;
+    t = trans_lookup(p, state, input);
+    if (t == NULL) {
+        t = trans_lookup(p, state, GSP_DEFAULT);
+    }
+    if (t == NULL) {
+        printf("gsp_step: not found\n");
+        *mods = NULL;
+        *key = NULL;
+        return 0;
+    }
+    *mods = t->out_mods;
+    *key = t->out_key;
+    return t->new_state;
+}
+/** Transition function lookup.
+ *
+ * Returns the value of the transition function for the given state
+ * and input. Note that the transition must be specified precisely,
+ * to obtain the default branch use input = GSP_DEFAULT.
+ *
+ * @param p     Parser.
+ * @param state     Current state.
+ * @param input     Input value.
+ * @return      The transition or @c NULL if not defined.
+ */
+static gsp_trans_t *trans_lookup(gsp_t *p, int state, int input)
+{
+    link_t *item;
+    unsigned long key[2];
+    key[0] = state;
+    key[1] = input;
+    item = hash_table_find(&p->trans, key);
+    if (item == NULL) return NULL;
+    return hash_table_get_instance(item, gsp_trans_t, link);
+}
+/** Define a new transition.
+ *
+ * @param p The parser.
+ * @param t Transition with all fields defined.
+ */
+static void trans_insert(gsp_t *p, gsp_trans_t *t)
+{
+    unsigned long key[2];
+    key[0] = t->old_state;
+    key[1] = t->input;
+    hash_table_insert(&p->trans, &key, &t->link);
+}
+/** Allocate transition structure. */
+static gsp_trans_t *trans_new(void)
+{
+    gsp_trans_t *t;
+    t = malloc(sizeof(gsp_trans_t));
+    if (t == NULL) {
+        printf("Memory allocation failed.\n");
+        exit(1);
+    }
+    return t;
+}
+/*
+ * Transition function hash table operations.
+ */
+static hash_index_t trans_op_hash(unsigned long key[])
+{
+    return (key[0] * 17 + key[1]) % TRANS_TABLE_CHAINS;
+}
+static int trans_op_compare(unsigned long key[], hash_count_t keys,
+    link_t *item)
+{
+    gsp_trans_t *t;
+    t = hash_table_get_instance(item, gsp_trans_t, link);
+    return (key[0] == t->old_state && key[1] == t->input);
+}
+static void trans_op_remove_callback(link_t *item)
+{
+}
+/**
+ * @}
+ */

 /branches/network/uspace/srv/kbd/generic/kbd.c
 ,48 → 37,99
 #include <ipc/ipc.h>
 #include <ipc/services.h>
+#include <sysinfo.h>
 #include <stdio.h>
 #include <unistd.h>
 #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/keycode.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"
 int cons_connected = 0;
 int phone2cons = -1;
-keybuffer_t keybuffer;
+keybuffer_t keybuffer;
-static void irq_handler(ipc_callid_t iid, ipc_call_t *call)
+/** Currently active modifiers. */
+static unsigned mods = KM_NUM_LOCK;
+/** Currently pressed lock keys. We track these to tackle autorepeat. */
+static unsigned lock_keys;
+int cir_service = 0;
+int cir_phone = -1;
+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);
+void kbd_push_ev(int type, unsigned int key)
+{
+    kbd_event_t ev;
+    unsigned mod_mask;
-    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;
+    switch (key) {
+    case KC_LCTRL: mod_mask = KM_LCTRL; break;
+    case KC_RCTRL: mod_mask = KM_RCTRL; break;
+    case KC_LSHIFT: mod_mask = KM_LSHIFT; break;
+    case KC_RSHIFT: mod_mask = KM_RSHIFT; break;
+    case KC_LALT: mod_mask = KM_LALT; break;
+    case KC_RALT: mod_mask = KM_RALT; break;
+    default: mod_mask = 0; break;
+    }
-            async_msg_1(phone2cons, KBD_PUSHCHAR, chr);
+    if (mod_mask != 0) {
+        if (type == KE_PRESS)
+            mods = mods | mod_mask;
+        else
+            mods = mods & ~mod_mask;
+    }
+    switch (key) {
+    case KC_CAPS_LOCK: mod_mask = KM_CAPS_LOCK; break;
+    case KC_NUM_LOCK: mod_mask = KM_NUM_LOCK; break;
+    case KC_SCROLL_LOCK: mod_mask = KM_SCROLL_LOCK; break;
+    default: mod_mask = 0; break;
+    }
+    if (mod_mask != 0) {
+        if (type == KE_PRESS) {
+            /*
+             * Only change lock state on transition from released
+             * to pressed. This prevents autorepeat from messing
+             * up the lock state.
+             */
+            mods = mods ^ (mod_mask & ~lock_keys);
+            lock_keys = lock_keys | mod_mask;
+        } else {
+            lock_keys = lock_keys & ~mod_mask;
         }
     }
+/*
+    printf("type: %d\n", type);
+    printf("mods: 0x%x\n", mods);
+    printf("keycode: %u\n", key);
+*/
+    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 console_connection(ipc_callid_t iid, ipc_call_t *icall)
 ,16 → 176,32
     ipcarg_t phonead;
-    /* Initialize arch dependent parts */
-    if (kbd_arch_init())
+    if (sysinfo_value("kbd.cir.fhc") == 1)
+        cir_service = SERVICE_FHC;
+    else if (sysinfo_value("kbd.cir.obio") == 1)
+        cir_service = SERVICE_OBIO;
+    if (cir_service) {
+        while (cir_phone < 0) {
+            cir_phone = ipc_connect_me_to_blocking(PHONE_NS, cir_service,
+, 0);
+        }
+    }
+    /* Initialize port driver. */
+    if (kbd_port_init() != 0)
         return -1;
+    /* Initialize controller driver. */
+    if (kbd_ctl_init() != 0)
+        return -1;
     /* Initialize key buffer */
     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 → 208,7
     printf(NAME ": Accepting connections\n");
     async_manager();
-    /* Never reached */
+    /* Not reached. */
     return 0;
 }

 /branches/network/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/network/uspace/srv/kbd/Makefile
 ,9 → 31,9
 LIBC_PREFIX = ../../lib/libc
 SOFTINT_PREFIX = ../../lib/softint
-include $(LIBC_PREFIX)/Makefile.toolchain
-include ../../../Makefile.config
+include $(LIBC_PREFIX)/Makefile.toolchain
 CFLAGS += -Iinclude -I../libadt/include
 LIBS = $(LIBC_PREFIX)/libc.a
 ,61 → 44,109
 OUTPUT = kbd
 GENERIC_SOURCES = \
     generic/kbd.c \
+    genarch/gsp.c \
+    genarch/stroke.c \
     generic/key_buffer.c
-ARCH_SOURCES = \
-    arch/$(ARCH)/src/kbd.c
+ARCH_SOURCES =
+GENARCH_SOURCES =
-ifeq ($(ARCH), ia32)
-    ARCH_SOURCES += \
-        arch/$(ARCH)/src/mouse.c \
-        arch/$(ARCH)/src/scanc.c
-    GENARCH_SOURCES = \
-        genarch/src/kbd.c
-    CFLAGS += -DMOUSE_ENABLED
+ifeq ($(KBD_LAYOUT), us_qwerty)
+    GENARCH_SOURCES += layout/us_qwerty.c
 endif
-ifeq ($(ARCH), amd64)
-    ARCH_SOURCES += \
-        arch/$(ARCH)/src/mouse.c \
-        arch/$(ARCH)/src/scanc.c
-    GENARCH_SOURCES = \
-        genarch/src/kbd.c
-    CFLAGS += -DMOUSE_ENABLED
+ifeq ($(KBD_LAYOUT), us_dvorak)
+    GENARCH_SOURCES += layout/us_dvorak.c
 endif
-ifeq ($(ARCH), sparc64)
-    ARCH_SOURCES += \
-        arch/$(ARCH)/src/scanc.c
-    GENARCH_SOURCES = \
-        genarch/src/kbd.c
+ifeq ($(UARCH), amd64)
+    GENARCH_SOURCES += \
+        port/i8042.c \
+        ctl/pc.c
 endif
-ifeq ($(ARCH), arm32)
-    ARCH_SOURCES += \
-        arch/$(ARCH)/src/kbd_gxemul.c
+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)
+    GENARCH_SOURCES += \
+        port/i8042.c \
+        ctl/pc.c
+endif
+ifeq ($(MACHINE), i460GX)
+    GENARCH_SOURCES += \
+        port/i8042.c \
+        ctl/pc.c
+endif
+ifeq ($(MACHINE), ski)
+    GENARCH_SOURCES += \
+        port/ski.c \
+        ctl/stty.c
+endif
+ifeq ($(MACHINE), msim)
+    GENARCH_SOURCES += \
+        port/msim.c \
+        ctl/stty.c
+endif
+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 ($(MACHINE), bgxemul)
+    GENARCH_SOURCES += \
+        port/gxemul.c \
+        ctl/stty.c
+endif
+ifeq ($(UARCH), ppc32)
+    GENARCH_SOURCES += \
+        port/dummy.c \
+        ctl/stty.c
+endif
+ifeq ($(UARCH), sparc64)
+    ifeq ($(MACHINE),serengeti)
+    GENARCH_SOURCES += \
+        port/sgcn.c \
+        ctl/stty.c
+    else
+    GENARCH_SOURCES += \
+        port/z8530.c \
+        ctl/sun.c
+    endif
+endif
 GENERIC_OBJECTS := $(addsuffix .o,$(basename $(GENERIC_SOURCES)))
 ARCH_OBJECTS := $(addsuffix .o,$(basename $(ARCH_SOURCES)))
 GENARCH_OBJECTS := $(addsuffix .o,$(basename $(GENARCH_SOURCES)))
+OBJECTS := $(ARCH_OBJECTS) $(GENERIC_OBJECTS) $(GENARCH_OBJECTS)
 .PHONY: all clean depend disasm links
-all: links $(OUTPUT) $(OUTPUT).disasm
+all: $(OUTPUT) $(OUTPUT).disasm
 -include Makefile.depend
-links:
-    ln -sfn ../arch/$(ARCH)/include include/arch
-    ln -sfn ../genarch/include include/genarch
 clean:
-    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend include/arch include/genarch
+    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend $(OBJECTS)
 depend:
     $(CC) $(DEFS) $(CFLAGS) -M $(SOURCES) > Makefile.depend
-$(OUTPUT): $(ARCH_OBJECTS) $(GENERIC_OBJECTS) $(GENARCH_OBJECTS) $(LIBS)
-    $(LD) -T $(LIBC_PREFIX)/arch/$(ARCH)/_link.ld $(GENERIC_OBJECTS) $(ARCH_OBJECTS) $(GENARCH_OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+$(OUTPUT): $(OBJECTS) $(LIBS)
+    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
 disasm: $(OUTPUT).disasm

 /branches/network/uspace/srv/kbd/layout/us_dvorak.c
 ,0 → 1,238
+/*
+ * 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 char map_lcase[] = {
+    [KC_R] = 'p',
+    [KC_T] = 'y',
+    [KC_Y] = 'f',
+    [KC_U] = 'g',
+    [KC_I] = 'c',
+    [KC_O] = 'r',
+    [KC_P] = 'l',
+    [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_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',
+};
+static char map_ucase[] = {
+    [KC_R] = 'P',
+    [KC_T] = 'Y',
+    [KC_Y] = 'F',
+    [KC_U] = 'G',
+    [KC_I] = 'C',
+    [KC_O] = 'R',
+    [KC_P] = 'L',
+    [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_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',
+};
+static char map_not_shifted[] = {
+    [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_Q] = '\'',
+    [KC_W] = ',',
+    [KC_E] = '.',
+    [KC_LBRACKET] = '/',
+    [KC_RBRACKET] = '=',
+    [KC_QUOTE] = '-',
+    [KC_BACKSLASH] = '\\',
+    [KC_Z] = ';',
+};
+static char map_shifted[] = {
+    [KC_BACKTICK] = '~',
+    [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_Q] = '"',
+    [KC_W] = '<',
+    [KC_E] = '>',
+    [KC_LBRACKET] = '?',
+    [KC_RBRACKET] = '+',
+    [KC_QUOTE] = '_',
+    [KC_BACKSLASH] = '|',
+    [KC_Z] = ':',
+};
+static char map_neutral[] = {
+    [KC_BACKSPACE] = '\b',
+    [KC_TAB] = '\t',
+    [KC_ENTER] = '\n',
+    [KC_SPACE] = ' ',
+    [KC_NSLASH] = '/',
+    [KC_NTIMES] = '*',
+    [KC_NMINUS] = '-',
+    [KC_NPLUS] = '+',
+    [KC_NENTER] = '\n'
+};
+static char map_numeric[] = {
+    [KC_N7] = '7',
+    [KC_N8] = '8',
+    [KC_N9] = '9',
+    [KC_N4] = '4',
+    [KC_N5] = '5',
+    [KC_N6] = '6',
+    [KC_N1] = '1',
+    [KC_N2] = '2',
+    [KC_N3] = '3',
+    [KC_N0] = '0',
+    [KC_NPERIOD] = '.'
+};
+static int translate(unsigned int key, char *map, size_t map_length)
+{
+    if (key >= map_length)
+        return 0;
+    return map[key];
+}
+char layout_parse_ev(kbd_event_t *ev)
+{
+    char c;
+    /* Produce no characters when Ctrl or Alt is pressed. */
+    if ((ev->mods & (KM_CTRL | KM_ALT)) != 0)
+        return 0;
+    c = translate(ev->key, map_neutral, sizeof(map_neutral) / sizeof(char));
+    if (c != 0)
+        return c;
+    if (((ev->mods & KM_SHIFT) != 0) ^ ((ev->mods & KM_CAPS_LOCK) != 0))
+        c = translate(ev->key, map_ucase, sizeof(map_ucase) / sizeof(char));
+    else
+        c = translate(ev->key, map_lcase, sizeof(map_lcase) / sizeof(char));
+    if (c != 0)
+        return c;
+    if ((ev->mods & KM_SHIFT) != 0)
+        c = translate(ev->key, map_shifted, sizeof(map_shifted) / sizeof(char));
+    else
+        c = translate(ev->key, map_not_shifted, sizeof(map_not_shifted) / sizeof(char));
+    if (c != 0)
+        return c;
+    if ((ev->mods & KM_NUM_LOCK) != 0)
+        c = translate(ev->key, map_numeric, sizeof(map_numeric) / sizeof(char));
+    else
+        c = 0;
+    return c;
+}
+/**
+ * @}
+ */

 /branches/network/uspace/srv/kbd/layout/us_qwerty.c
 ,0 → 1,228
+/*
+ * 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 char map_lcase[] = {
+    [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_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_Z] = 'z',
+    [KC_X] = 'x',
+    [KC_C] = 'c',
+    [KC_V] = 'v',
+    [KC_B] = 'b',
+    [KC_N] = 'n',
+    [KC_M] = 'm',
+};
+static char map_ucase[] = {
+    [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_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_Z] = 'Z',
+    [KC_X] = 'X',
+    [KC_C] = 'C',
+    [KC_V] = 'V',
+    [KC_B] = 'B',
+    [KC_N] = 'N',
+    [KC_M] = 'M',
+};
+static char map_not_shifted[] = {
+    [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_LBRACKET] = '[',
+    [KC_RBRACKET] = ']',
+    [KC_SEMICOLON] = ';',
+    [KC_QUOTE] = '\'',
+    [KC_BACKSLASH] = '\\',
+    [KC_COMMA] = ',',
+    [KC_PERIOD] = '.',
+    [KC_SLASH] = '/',
+};
+static char map_shifted[] = {
+    [KC_BACKTICK] = '~',
+    [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_LBRACKET] = '{',
+    [KC_RBRACKET] = '}',
+    [KC_SEMICOLON] = ':',
+    [KC_QUOTE] = '"',
+    [KC_BACKSLASH] = '|',
+    [KC_COMMA] = '<',
+    [KC_PERIOD] = '>',
+    [KC_SLASH] = '?',
+};
+static char map_neutral[] = {
+    [KC_BACKSPACE] = '\b',
+    [KC_TAB] = '\t',
+    [KC_ENTER] = '\n',
+    [KC_SPACE] = ' ',
+    [KC_NSLASH] = '/',
+    [KC_NTIMES] = '*',
+    [KC_NMINUS] = '-',
+    [KC_NPLUS] = '+',
+    [KC_NENTER] = '\n'
+};
+static char map_numeric[] = {
+    [KC_N7] = '7',
+    [KC_N8] = '8',
+    [KC_N9] = '9',
+    [KC_N4] = '4',
+    [KC_N5] = '5',
+    [KC_N6] = '6',
+    [KC_N1] = '1',
+    [KC_N2] = '2',
+    [KC_N3] = '3',
+    [KC_N0] = '0',
+    [KC_NPERIOD] = '.'
+};
+static int translate(unsigned int key, char *map, size_t map_length)
+{
+    if (key >= map_length) return 0;
+    return map[key];
+}
+char layout_parse_ev(kbd_event_t *ev)
+{
+    char c;
+    /* Produce no characters when Ctrl or Alt is pressed. */
+    if ((ev->mods & (KM_CTRL | KM_ALT)) != 0)
+        return 0;
+    c = translate(ev->key, map_neutral, sizeof(map_neutral) / sizeof(char));
+    if (c != 0) return c;
+    if (((ev->mods & KM_SHIFT) != 0) ^ ((ev->mods & KM_CAPS_LOCK) != 0))
+        c = translate(ev->key, map_ucase, sizeof(map_ucase) / sizeof(char));
+    else
+        c = translate(ev->key, map_lcase, sizeof(map_lcase) / sizeof(char));
+    if (c != 0) return c;
+    if ((ev->mods & KM_SHIFT) != 0)
+        c = translate(ev->key, map_shifted, sizeof(map_shifted) / sizeof(char));
+    else
+        c = translate(ev->key, map_not_shifted, sizeof(map_not_shifted) / sizeof(char));
+    if (c != 0) return c;
+    if ((ev->mods & KM_NUM_LOCK) != 0)
+        c = translate(ev->key, map_numeric, sizeof(map_numeric) / sizeof(char));
+    else
+        c = 0;
+    return c;
+}
+/**
+ * @}
+ */

 /branches/network/uspace/srv/ns/ns.c
 ,11 → 28,11
 /** @addtogroup ns
  * @{
- */
+ */
 /**
- * @file    ns.c
- * @brief   Naming service for HelenOS IPC.
+ * @file  ns.c
+ * @brief Naming service for HelenOS IPC.
  */
 ,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>
 ,17 → 48,24
 #include <libadt/list.h>
 #include <libadt/hash_table.h>
 #include <sysinfo.h>
+#include <loader/loader.h>
 #include <ddi.h>
 #include <as.h>
-#define NAME    "ns"
+#define NAME  "ns"
-#define NS_HASH_TABLE_CHAINS    20
+#define NS_HASH_TABLE_CHAINS  20
 static int register_service(ipcarg_t service, ipcarg_t phone, ipc_call_t *call);
-static int connect_to_service(ipcarg_t service, ipc_call_t *call,
+static void 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);
 ,19 → 84,46
 /** NS hash table item. */
 typedef struct {
     link_t link;
-    ipcarg_t service;       /**< Number of the service. */
-    ipcarg_t phone;         /**< Phone registered with the service. */
-    ipcarg_t in_phone_hash;     /**< Incoming phone hash. */
+    ipcarg_t service;        /**< Number of the service. */
+    ipcarg_t phone;          /**< Phone registered with the service. */
+    ipcarg_t in_phone_hash;  /**< Incoming phone hash. */
 } hashed_service_t;
+/** Pending connection structure. */
+typedef struct {
+    link_t link;
+    ipcarg_t service;        /**< Number of the service. */
+    ipc_callid_t callid;     /**< Call ID waiting for the connection */
+    ipcarg_t arg2;           /**< Second argument */
+    ipcarg_t arg3;           /**< Third argument */
+} pending_req_t;
+static link_t pending_req;
+/** 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;
 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)
+/** 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) {
 ,40 → 131,76
             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);
 }
+/** Process pending connection requests */
+static void process_pending_req()
+{
+    link_t *cur;
+loop:
+    for (cur = pending_req.next; cur != &pending_req; cur = cur->next) {
+        pending_req_t *pr = list_get_instance(cur, pending_req_t, link);
+        unsigned long keys[3] = {
+            pr->service,
+,
+        };
+        link_t *link = hash_table_find(&ns_hash_table, keys);
+        if (!link)
+            continue;
+        hashed_service_t *hs = hash_table_get_instance(link, hashed_service_t, link);
+        ipcarg_t retval = ipc_forward_fast(pr->callid, hs->phone,
+            pr->arg2, pr->arg3, 0, IPC_FF_NONE);
+        if (!(pr->callid & IPC_CALLID_NOTIFICATION))
+            ipc_answer_0(pr->callid, retval);
+        list_remove(cur);
+        free(pr);
+        goto loop;
+    }
+}
 int main(int argc, char **argv)
 {
     printf(NAME ": HelenOS IPC Naming Service\n");
-    ipc_call_t call;
-    ipc_callid_t callid;
-    ipcarg_t retval;
     if (!hash_table_create(&ns_hash_table, NS_HASH_TABLE_CHAINS, 3,
         &ns_hash_table_ops)) {
-        printf(NAME ": No memory available\n");
+        printf(NAME ": No memory available for services\n");
         return ENOMEM;
     }
+    list_initialize(&pending_req);
+    list_initialize(&cs_req);
     printf(NAME ": Accepting connections\n");
-    while (1) {
-        callid = ipc_wait_for_call(&call);
+    while (true) {
+        process_pending_req();
+        ipc_call_t call;
+        ipc_callid_t callid = ipc_wait_for_call(&call);
+        ipcarg_t retval;
         switch (IPC_GET_METHOD(call)) {
         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);
 ,23 → 213,36
             /*
              * 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 {
+                connect_to_service(IPC_GET_ARG1(call), &call,
+                    callid);
+                continue;
+            }
             break;
         default:
             retval = ENOENT;
             break;
         }
-        if (!(callid & IPC_CALLID_NOTIFICATION)) {
+        if (!(callid & IPC_CALLID_NOTIFICATION))
             ipc_answer_0(callid, retval);
-        }
     }
     /* Not reached */
 ,10 → 252,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 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.
+ *
  */
 int register_service(ipcarg_t service, ipcarg_t phone, ipc_call_t *call)
 {
 ,23 → 265,20
         call->in_phone_hash,
     };
-    hashed_service_t *hs;
-    if (hash_table_find(&ns_hash_table, keys)) {
+    if (hash_table_find(&ns_hash_table, keys))
         return EEXISTS;
-    }
-    hs = (hashed_service_t *) malloc(sizeof(hashed_service_t));
-    if (!hs) {
+    hashed_service_t *hs = (hashed_service_t *) malloc(sizeof(hashed_service_t));
+    if (!hs)
         return ENOMEM;
-    }
     link_initialize(&hs->link);
     hs->service = service;
     hs->phone = phone;
     hs->in_phone_hash = call->in_phone_hash;
     hash_table_insert(&ns_hash_table, keys, &hs->link);
     return 0;
 }
 ,36 → 285,135
 /** 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 call    Pointer to call structure.
+ * @param callid  Call ID of the request.
  *
  * @return Zero on success or a value from @ref errno.h.
+ *
  */
-int connect_to_service(ipcarg_t service, ipc_call_t *call, ipc_callid_t callid)
+void connect_to_service(ipcarg_t service, ipc_call_t *call, ipc_callid_t callid)
 {
-    unsigned long keys[3] = { service, 0, 0 };
-    link_t *hlp;
-    hashed_service_t *hs;
+    ipcarg_t retval;
+    unsigned long keys[3] = {
+        service,
+,
+    };
+    link_t *link = hash_table_find(&ns_hash_table, keys);
+    if (!link) {
+        if (IPC_GET_ARG4(*call) & IPC_FLAG_BLOCKING) {
+            /* Blocking connection, add to pending list */
+            pending_req_t *pr = (pending_req_t *) malloc(sizeof(pending_req_t));
+            if (!pr) {
+                retval = ENOMEM;
+                goto out;
+            }
-    hlp = hash_table_find(&ns_hash_table, keys);
-    if (!hlp) {
-        return ENOENT;
+            pr->service = service;
+            pr->callid = callid;
+            pr->arg2 = IPC_GET_ARG2(*call);
+            pr->arg3 = IPC_GET_ARG3(*call);
+            list_append(&pr->link, &pending_req);
+            return;
+        }
+        retval = ENOENT;
+        goto out;
     }
-    hs = hash_table_get_instance(hlp, hashed_service_t, link);
-    return ipc_forward_fast(callid, hs->phone, IPC_GET_ARG2(*call),
-        IPC_GET_ARG3(*call), 0, IPC_FF_NONE);
+    hashed_service_t *hs = hash_table_get_instance(link, hashed_service_t, link);
+    retval = ipc_forward_fast(callid, hs->phone, IPC_GET_ARG2(*call),
+        IPC_GET_ARG3(*call), 0, IPC_FF_NONE);
+out:
+    if (!(callid & IPC_CALLID_NOTIFICATION))
+        ipc_answer_0(callid, retval);
 }
+/** 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)
+{
+    if (list_empty(&cs_req)) {
+        /* There was no pending connection request. */
+        printf(NAME ": Unexpected clonable server.\n");
+        ipc_answer_0(callid, EBUSY);
+        return;
+    }
+    cs_req_t *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);
+    int 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)
+{
+    assert(service == SERVICE_LOAD);
+    cs_req_t *csr = malloc(sizeof(cs_req_t));
+    if (csr == NULL) {
+        ipc_answer_0(callid, ENOMEM);
+        return;
+    }
+    /* Spawn a loader. */
+    int 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)
- *        is used to compute the hash index.
+ *            is used to compute the hash index.
+ *
  * @return Hash index corresponding to key[0].
+ *
  */
 hash_index_t ns_hash(unsigned long *key)
 {
     assert(key);
-    return *key % NS_HASH_TABLE_CHAINS;
+    return (*key % NS_HASH_TABLE_CHAINS);
 }
 /** Compare a key with hashed item.
 ,20 → 424,20
  * value. Note that this is close to being classified
  * as a nasty hack.
  *
- * @param key Array of keys.
+ * @param key  Array of keys.
  * @param keys Must be lesser or equal to 3.
  * @param item Pointer to a hash table item.
+ *
  * @return Non-zero if the key matches the item, zero otherwise.
+ *
  */
 int ns_compare(unsigned long key[], hash_count_t keys, link_t *item)
 {
-    hashed_service_t *hs;
     assert(key);
     assert(keys <= 3);
     assert(item);
-    hs = hash_table_get_instance(item, hashed_service_t, link);
+    hashed_service_t *hs = hash_table_get_instance(item, hashed_service_t, link);
     if (keys == 2)
         return key[1] == hs->in_phone_hash;
 ,6 → 448,7
 /** Perform actions after removal of item from the hash table.
  *
  * @param item Item that was removed from the hash table.
+ *
  */
 void ns_remove(link_t *item)
 {
 ,6 → 456,6
     free(hash_table_get_instance(item, hashed_service_t, link));
 }
-/**
+/**
  * @}
  */

 /branches/network/uspace/srv/ns/Makefile
 ,6 → 31,7
 LIBC_PREFIX = ../../lib/libc
 SOFTINT_PREFIX = ../../lib/softint
 include $(LIBC_PREFIX)/Makefile.toolchain
 LIBS = $(LIBC_PREFIX)/libc.a
 ,13 → 52,13
 -include Makefile.depend
 clean:
-    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend
+    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend $(OBJECTS)
 depend:
     $(CC) $(DEFS) $(CFLAGS) -M $(SOURCES) > Makefile.depend
 $(OUTPUT): $(OBJECTS) $(LIBS)
-    $(LD) -T $(LIBC_PREFIX)/arch/$(ARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
 disasm: $(OUTPUT).disasm

 /branches/network/uspace/srv/fhc/fhc.c
 ,0 → 1,157
+/*
+ * Copyright (c) 2009 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 fhc
+ * @{
+ */
+/**
+ * @file    fhc.c
+ * @brief   FHC bus controller driver.
+ */
+#include <ipc/ipc.h>
+#include <ipc/services.h>
+#include <ipc/bus.h>
+#include <ipc/ns.h>
+#include <sysinfo.h>
+#include <as.h>
+#include <ddi.h>
+#include <align.h>
+#include <bool.h>
+#include <errno.h>
+#include <async.h>
+#include <align.h>
+#include <async.h>
+#include <stdio.h>
+#include <ipc/devmap.h>
+#define NAME "fhc"
+#define FHC_UART_INR    0x39
+#define FHC_UART_IMAP   0x0
+#define FHC_UART_ICLR   0x4
+static void *fhc_uart_phys;
+static volatile uint32_t *fhc_uart_virt;
+static size_t fhc_uart_size;
+/** Handle one connection to fhc.
+ *
+ * @param iid       Hash of the request that opened the connection.
+ * @param icall     Call data of the request that opened the connection.
+ */
+static void fhc_connection(ipc_callid_t iid, ipc_call_t *icall)
+{
+    ipc_callid_t callid;
+    ipc_call_t call;
+    /*
+     * Answer the first IPC_M_CONNECT_ME_TO call.
+     */
+    ipc_answer_0(iid, EOK);
+    while (1) {
+        int inr;
+        callid = async_get_call(&call);
+        switch (IPC_GET_METHOD(call)) {
+        case BUS_CLEAR_INTERRUPT:
+            inr = IPC_GET_ARG1(call);
+            switch (inr) {
+            case FHC_UART_INR:
+                fhc_uart_virt[FHC_UART_ICLR] = 0;
+                ipc_answer_0(callid, EOK);
+                break;
+            default:
+                ipc_answer_0(callid, ENOTSUP);
+                break;
+            }
+            break;
+        default:
+            ipc_answer_0(callid, EINVAL);
+            break;
+        }
+    }
+}
+/** Initialize the FHC driver.
+ *
+ * So far, the driver heavily depends on information provided by the kernel via
+ * sysinfo. In the future, there should be a standalone FHC driver.
+ */
+static bool fhc_init(void)
+{
+    ipcarg_t phonead;
+    fhc_uart_size = sysinfo_value("fhc.uart.size");
+    fhc_uart_phys = (void *) sysinfo_value("fhc.uart.physical");
+    if (!fhc_uart_size) {
+        printf(NAME ": no FHC UART registers found\n");
+        return false;
+    }
+    fhc_uart_virt = as_get_mappable_page(fhc_uart_size);
+    int flags = AS_AREA_READ | AS_AREA_WRITE;
+    int retval = physmem_map(fhc_uart_phys, (void *) fhc_uart_virt,
+        ALIGN_UP(fhc_uart_size, PAGE_SIZE) >> PAGE_WIDTH, flags);
+    if (retval < 0) {
+        printf(NAME ": Error mapping FHC UART registers\n");
+        return false;
+    }
+    printf(NAME ": FHC UART registers at %p, %d bytes\n", fhc_uart_phys,
+        fhc_uart_size);
+    async_set_client_connection(fhc_connection);
+    ipc_connect_to_me(PHONE_NS, SERVICE_FHC, 0, 0, &phonead);
+    return true;
+}
+int main(int argc, char **argv)
+{
+    printf(NAME ": HelenOS FHC bus controller driver\n");
+    if (!fhc_init())
+        return -1;
+    printf(NAME ": Accepting connections\n");
+    async_manager();
+    /* Never reached */
+    return 0;
+}
+/**
+ * @}
+ */

 /branches/network/uspace/srv/fhc/Makefile
 ,0 → 1,76
+#
+# 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.
+#
+## Setup toolchain
+#
+LIBC_PREFIX = ../../lib/libc
+SOFTINT_PREFIX = ../../lib/softint
+include $(LIBC_PREFIX)/Makefile.toolchain
+LIBS = $(LIBC_PREFIX)/libc.a
+## Sources
+#
+OUTPUT = fhc
+SOURCES = \
+    fhc.c
+OBJECTS := $(addsuffix .o,$(basename $(SOURCES)))
+.PHONY: all clean depend disasm
+all: $(OUTPUT) $(OUTPUT).disasm
+-include Makefile.depend
+clean:
+    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend $(OBJECTS)
+depend:
+    $(CC) $(DEFS) $(CFLAGS) -M $(SOURCES) > Makefile.depend
+$(OUTPUT): $(OBJECTS) $(LIBS)
+    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+disasm: $(OUTPUT).disasm
+$(OUTPUT).disasm: $(OUTPUT)
+    $(OBJDUMP) -d $< >$@
+%.o: %.S
+    $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@
+%.o: %.s
+    $(AS) $(AFLAGS) $< -o $@
+%.o: %.c
+    $(CC) $(DEFS) $(CFLAGS) -c $< -o $@

 /branches/network/uspace/srv/console/console.c
 ,12 → 35,13
 #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>
 #include <key_buffer.h>
-#include <console.h>
+#include <ipc/console.h>
 #include <unistd.h>
 #include <async.h>
 #include <libadt/fifo.h>
 ,7 → 48,9
 #include <screenbuffer.h>
 #include <sys/mman.h>
 #include <stdio.h>
+#include <sysinfo.h>
+#include "console.h"
 #include "gcons.h"
 #define MAX_KEYREQUESTS_BUFFERED 32
 ,6 → 60,7
 /** Index of currently used virtual console.
  */
 int active_console = 0;
+int prev_console = 0;
 /** Information about framebuffer
  */
 ,10 → 90,7
                          * faster virtual console
                          * switching */
-static int kernel_pixmap = -1;  /**< Number of fb pixmap, where kernel
-                 * console is stored */
 /** Find unused virtual console.
  *
  */
 ,27 → 110,54
     async_msg_0(fb_info.phone, FB_CLEAR);
 }
-static void curs_visibility(int v)
+static void curs_visibility(bool visible)
 {
-    async_msg_1(fb_info.phone, FB_CURSOR_VISIBILITY, v);
+    async_msg_1(fb_info.phone, FB_CURSOR_VISIBILITY, visible);
 }
+static void curs_hide_sync(void)
+{
+    ipc_call_sync_1_0(fb_info.phone, FB_CURSOR_VISIBILITY, false);
+}
 static void curs_goto(int row, int col)
 {
     async_msg_2(fb_info.phone, FB_CURSOR_GOTO, row, col);
 }
-static void set_style(style_t *style)
+static void set_style(int style)
 {
-    async_msg_2(fb_info.phone, FB_SET_STYLE, style->fg_color,
-        style->bg_color);
+    async_msg_1(fb_info.phone, FB_SET_STYLE, style);
 }
-static void set_style_col(int fgcolor, int bgcolor)
+static void set_color(int fgcolor, int bgcolor, int flags)
 {
-    async_msg_2(fb_info.phone, FB_SET_STYLE, fgcolor, bgcolor);
+    async_msg_3(fb_info.phone, FB_SET_COLOR, fgcolor, bgcolor, flags);
 }
+static void set_rgb_color(int fgcolor, int bgcolor)
+{
+    async_msg_2(fb_info.phone, FB_SET_RGB_COLOR, fgcolor, bgcolor);
+}
+static void set_attrs(attrs_t *attrs)
+{
+    switch (attrs->t) {
+    case at_style:
+        set_style(attrs->a.s.style);
+        break;
+    case at_idx:
+        set_color(attrs->a.i.fg_color, attrs->a.i.bg_color,
+            attrs->a.i.flags);
+        break;
+    case at_rgb:
+        set_rgb_color(attrs->a.r.fg_color, attrs->a.r.bg_color);
+        break;
+    }
+}
 static void prtchr(char c, int row, int col)
 {
     async_msg_3(fb_info.phone, FB_PUTCHAR, c, row, col);
 ,114 → 215,81
 }
-/** Save current screen to pixmap, draw old pixmap
- *
- * @param oldpixmap Old pixmap
- * @return ID of pixmap of current screen
- */
-static int switch_screens(int oldpixmap)
-{
-    int newpmap;
-    /* Save screen */
-    newpmap = async_req_0_0(fb_info.phone, FB_VP2PIXMAP);
-    if (newpmap < 0)
-        return -1;
-    if (oldpixmap != -1) {
-        /* Show old screen */
-        async_msg_2(fb_info.phone, FB_VP_DRAW_PIXMAP, 0, oldpixmap);
-        /* Drop old pixmap */
-        async_msg_1(fb_info.phone, FB_DROP_PIXMAP, oldpixmap);
-    }
-    return newpmap;
-}
 /** Switch to new console */
 static void change_console(int newcons)
 {
     connection_t *conn;
-    static int console_pixmap = -1;
     int i, j, rc;
     keyfield_t *field;
-    style_t *style;
+    attrs_t *attrs;
     if (newcons == active_console)
         return;
     if (newcons == KERNEL_CONSOLE) {
-        if (active_console == KERNEL_CONSOLE)
-            return;
-        active_console = KERNEL_CONSOLE;
-        curs_visibility(0);
         async_serialize_start();
-        if (kernel_pixmap == -1) {
-            /* store/restore unsupported */
-            set_style_col(DEFAULT_FOREGROUND, DEFAULT_BACKGROUND);
-            clrscr();
-        } else {
-            gcons_in_kernel();
-            console_pixmap = switch_screens(kernel_pixmap);
-            kernel_pixmap = -1;
-        }
+        curs_hide_sync();
+        gcons_in_kernel();
         async_serialize_end();
-        __SYSCALL0(SYS_DEBUG_ENABLE_CONSOLE);
-        return;
-    }
-    async_serialize_start();
-    if (console_pixmap != -1) {
-        kernel_pixmap = switch_screens(console_pixmap);
-        console_pixmap = -1;
+        if (__SYSCALL0(SYS_DEBUG_ENABLE_CONSOLE)) {
+            prev_console = active_console;
+            active_console = KERNEL_CONSOLE;
+        } else
+            newcons = active_console;
     }
-    active_console = newcons;
-    gcons_change_console(newcons);
-    conn = &connections[active_console];
-    set_style(&conn->screenbuffer.style);
-    curs_visibility(0);
-    if (interbuffer) {
-        for (i = 0; i < conn->screenbuffer.size_x; i++)
-            for (j = 0; j < conn->screenbuffer.size_y; j++) {
-                unsigned int size_x;
-                size_x = conn->screenbuffer.size_x;
-                interbuffer[i + j * size_x] =
-                    *get_field_at(&conn->screenbuffer, i, j);
-            }
-        /* This call can preempt, but we are already at the end */
-        rc = async_req_0_0(fb_info.phone, FB_DRAW_TEXT_DATA);
-    }
-    if ((!interbuffer) || (rc != 0)) {
-        set_style(&conn->screenbuffer.style);
-        clrscr();
-        style = &conn->screenbuffer.style;
+    if (newcons != KERNEL_CONSOLE) {
+        async_serialize_start();
+        if (active_console == KERNEL_CONSOLE)
+            gcons_redraw_console();
+        active_console = newcons;
+        gcons_change_console(newcons);
+        conn = &connections[active_console];
+        set_attrs(&conn->screenbuffer.attrs);
+        curs_visibility(false);
+        if (interbuffer) {
+            for (i = 0; i < conn->screenbuffer.size_x; i++)
+                for (j = 0; j < conn->screenbuffer.size_y; j++) {
+                    unsigned int size_x;
+                    size_x = conn->screenbuffer.size_x;
+                    interbuffer[i + j * size_x] =
+                        *get_field_at(&conn->screenbuffer, i, j);
+                }
+            /* This call can preempt, but we are already at the end */
+            rc = async_req_0_0(fb_info.phone, FB_DRAW_TEXT_DATA);
+        }
+        if ((!interbuffer) || (rc != 0)) {
+            set_attrs(&conn->screenbuffer.attrs);
+            clrscr();
+            attrs = &conn->screenbuffer.attrs;
+            for (j = 0; j < conn->screenbuffer.size_y; j++)
+                for (i = 0; i < conn->screenbuffer.size_x; i++) {
+                    field = get_field_at(&conn->screenbuffer, i, j);
+                    if (!attrs_same(*attrs, field->attrs))
+                        set_attrs(&field->attrs);
+                    attrs = &field->attrs;
+                    if ((field->character == ' ') &&
+                        (attrs_same(field->attrs,
+                        conn->screenbuffer.attrs)))
+                        continue;
-        for (j = 0; j < conn->screenbuffer.size_y; j++)
-            for (i = 0; i < conn->screenbuffer.size_x; i++) {
-                field = get_field_at(&conn->screenbuffer, i, j);
-                if (!style_same(*style, field->style))
-                    set_style(&field->style);
-                style = &field->style;
-                if ((field->character == ' ') &&
-                    (style_same(field->style,
-                    conn->screenbuffer.style)))
-                    continue;
-                prtchr(field->character, j, i);
-            }
+                    prtchr(field->character, j, i);
+                }
+        }
+        curs_goto(conn->screenbuffer.position_y,
+            conn->screenbuffer.position_x);
+        curs_visibility(conn->screenbuffer.is_cursor_visible);
+        async_serialize_end();
     }
-    curs_goto(conn->screenbuffer.position_y,
-        conn->screenbuffer.position_x);
-    curs_visibility(conn->screenbuffer.is_cursor_visible);
-    async_serialize_end();
 }
 /** Handler for keyboard */
 ,7 → 298,7
     ipc_callid_t callid;
     ipc_call_t call;
     int retval;
-    int c;
+    kbd_event_t ev;
     connection_t *conn;
     int newcon;
 ,23 → 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;
+            ev.type = IPC_GET_ARG1(call);
+            ev.key = IPC_GET_ARG2(call);
+            ev.mods = IPC_GET_ARG3(call);
+            ev.c = IPC_GET_ARG4(call);
-            retval = 0;
-            c = IPC_GET_ARG1(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;
 ,9 → 366,9
     ipc_callid_t callid;
     ipc_call_t call;
     int consnum;
-    ipcarg_t arg1, arg2;
+    ipcarg_t arg1, arg2, arg3, arg4;
     connection_t *conn;
     if ((consnum = find_free_connection()) == -1) {
         ipc_answer_0(iid, ELIMIT);
         return;
 ,20 → 383,23
     /* Accept the connection */
     ipc_answer_0(iid, EOK);
     while (1) {
         async_serialize_end();
         callid = async_get_call(&call);
         async_serialize_start();
         arg1 = 0;
         arg2 = 0;
+        arg3 = 0;
+        arg4 = 0;
         switch (IPC_GET_METHOD(call)) {
         case IPC_M_PHONE_HUNGUP:
             gcons_notify_disconnect(consnum);
             /* Answer all pending requests */
-            while (conn->keyrequest_counter > 0) {
+            while (conn->keyrequest_counter > 0) {
                 conn->keyrequest_counter--;
                 ipc_answer_0(fifo_pop(conn->keyrequests),
                     ENOENT);
 ,11 → 437,26
             break;
         case CONSOLE_SET_STYLE:
             arg1 = IPC_GET_ARG1(call);
+            screenbuffer_set_style(&conn->screenbuffer, arg1);
+            if (consnum == active_console)
+                set_style(arg1);
+            break;
+        case CONSOLE_SET_COLOR:
+            arg1 = IPC_GET_ARG1(call);
             arg2 = IPC_GET_ARG2(call);
-            screenbuffer_set_style(&conn->screenbuffer, arg1,
+            arg3 = IPC_GET_ARG3(call);
+            screenbuffer_set_color(&conn->screenbuffer, arg1,
+                arg2, arg3);
+            if (consnum == active_console)
+                set_color(arg1, arg2, arg3);
+            break;
+        case CONSOLE_SET_RGB_COLOR:
+            arg1 = IPC_GET_ARG1(call);
+            arg2 = IPC_GET_ARG2(call);
+            screenbuffer_set_rgb_color(&conn->screenbuffer, arg1,
                 arg2);
             if (consnum == active_console)
-                set_style_col(arg1, arg2);
+                set_rgb_color(arg1, arg2);
             break;
         case CONSOLE_CURSOR_VISIBILITY:
             arg1 = IPC_GET_ARG1(call);
 ,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 <
 ,13 → 480,23
                 }
                 continue;
             }
-            keybuffer_pop(&conn->keybuffer, (int *) &arg1);
+            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);
     }
 }
+static void interrupt_received(ipc_callid_t callid, ipc_call_t *call)
+{
+    change_console(prev_console);
+}
 int main(int argc, char *argv[])
 {
     printf(NAME ": HelenOS Console service\n");
 ,43 → 503,43
     ipcarg_t phonehash;
     int kbd_phone;
+    size_t ib_size;
     int i;
     async_set_client_connection(client_connection);
     /* Connect to keyboard driver */
-    kbd_phone = ipc_connect_me_to(PHONE_NS, SERVICE_KEYBOARD, 0, 0);
-    while (kbd_phone < 0) {
-        usleep(10000);
-        kbd_phone = ipc_connect_me_to(PHONE_NS, SERVICE_KEYBOARD, 0, 0);
+    kbd_phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_KEYBOARD, 0, 0);
+    if (kbd_phone < 0) {
+        printf(NAME ": Failed to connect to keyboard service\n");
+        return -1;
     }
-    if (ipc_connect_to_me(kbd_phone, SERVICE_CONSOLE, 0, 0, &phonehash) != 0)
+    if (ipc_connect_to_me(kbd_phone, SERVICE_CONSOLE, 0, 0, &phonehash) != 0) {
+        printf(NAME ": Failed to create callback from keyboard service\n");
         return -1;
+    }
     async_new_connection(phonehash, 0, NULL, keyboard_events);
     /* Connect to framebuffer driver */
-    fb_info.phone = ipc_connect_me_to(PHONE_NS, SERVICE_VIDEO, 0, 0);
-    while (fb_info.phone < 0) {
-        usleep(10000);
-        fb_info.phone = ipc_connect_me_to(PHONE_NS, SERVICE_VIDEO, 0, 0);
+    fb_info.phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_VIDEO, 0, 0);
+    if (fb_info.phone < 0) {
+        printf(NAME ": Failed to connect to video service\n");
+        return -1;
     }
-    /* Save old kernel screen */
-    kernel_pixmap = switch_screens(-1);
+    /* Disable kernel output to the console */
+    __SYSCALL0(SYS_DEBUG_DISABLE_CONSOLE);
     /* Initialize gcons */
     gcons_init(fb_info.phone);
     /* Synchronize, the gcons can have something in queue */
     async_req_0_0(fb_info.phone, FB_FLUSH);
-    /* Enable double buffering */
-    async_msg_2(fb_info.phone, FB_VIEWPORT_DB, (sysarg_t) -1, 1);
     async_req_0_2(fb_info.phone, FB_GET_CSIZE, &fb_info.rows,
         &fb_info.cols);
-    set_style_col(DEFAULT_FOREGROUND, DEFAULT_BACKGROUND);
+    set_rgb_color(DEFAULT_FOREGROUND, DEFAULT_BACKGROUND);
     clrscr();
     /* Init virtual consoles */
 ,33 → 559,47
         }
     }
     connections[KERNEL_CONSOLE].used = 1;
-    interbuffer = mmap(NULL,
-        sizeof(keyfield_t) * fb_info.cols * fb_info.rows,
-        PROTO_READ | PROTO_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
-    if (!interbuffer) {
+    /* Set up shared memory buffer. */
+    ib_size = sizeof(keyfield_t) * fb_info.cols * fb_info.rows;
+    interbuffer = as_get_mappable_page(ib_size);
+    if (as_area_create(interbuffer, ib_size, AS_AREA_READ |
+        AS_AREA_WRITE | AS_AREA_CACHEABLE) != interbuffer) {
+        interbuffer = NULL;
+    }
+    if (interbuffer) {
         if (ipc_share_out_start(fb_info.phone, interbuffer,
             AS_AREA_READ) != EOK) {
-            munmap(interbuffer,
-                sizeof(keyfield_t) * fb_info.cols * fb_info.rows);
+            as_area_destroy(interbuffer);
             interbuffer = NULL;
         }
     }
     curs_goto(0, 0);
     curs_visibility(
         connections[active_console].screenbuffer.is_cursor_visible);
     /* Register at NS */
     if (ipc_connect_to_me(PHONE_NS, SERVICE_CONSOLE, 0, 0, &phonehash) != 0)
         return -1;
+    /* Receive kernel notifications */
+//  if (sysinfo_value("kconsole.present")) {
+//      int inr = sysinfo_value("kconsole.inr");
+//      if (ipc_register_irq(inr, device_assign_devno(), 0, NULL) != EOK)
+//          printf(NAME ": Error registering kconsole notifications\n");
+//
+//      async_set_interrupt_received(interrupt_received);
+//  }
     // FIXME: avoid connectiong to itself, keep using klog
     // printf(NAME ": Accepting connections\n");
     async_manager();
+    return 0;
+}
-    return 0;
-}
 /** @}
  */

 /branches/network/uspace/srv/console/console.h
 ,15 → 39,6
 #define CONSOLE_COUNT 12
-#define CONSOLE_GETCHAR     1026
-#define CONSOLE_PUTCHAR     1027
-#define CONSOLE_CLEAR       1028
-#define CONSOLE_GOTO        1029
-#define CONSOLE_GETSIZE     1030
-#define CONSOLE_FLUSH       1031
-#define CONSOLE_SET_STYLE   1032
-#define CONSOLE_CURSOR_VISIBILITY   1033
 #endif
 /** @}

 /branches/network/uspace/srv/console/screenbuffer.c
 ,6 → 33,7
  */
 #include <screenbuffer.h>
+#include <console/style.h>
 #include <malloc.h>
 #include <unistd.h>
 ,7 → 50,7
     field = get_field_at(scr, scr->position_x, scr->position_y);
     field->character = c;
-    field->style = scr->style;
+    field->attrs = scr->attrs;
 }
 /** Initilize screenbuffer. Allocate space for screen content in accordance to given size.
 ,8 → 68,8
     scr->size_x = size_x;
     scr->size_y = size_y;
-    scr->style.fg_color = DEFAULT_FOREGROUND;
-    scr->style.bg_color = DEFAULT_BACKGROUND;
+    scr->attrs.t = at_style;
+    scr->attrs.a.s.style = STYLE_NORMAL;
     scr->is_cursor_visible = 1;
     screenbuffer_clear(scr);
 ,7 → 86,7
     for (i = 0; i < (scr->size_x * scr->size_y); i++) {
         scr->buffer[i].character = ' ';
-        scr->buffer[i].style = scr->style;
+        scr->buffer[i].attrs = scr->attrs;
     }
     scr->top_line = 0;
 ,7 → 104,7
     for (i = 0; i < scr->size_x; i++) {
         scr->buffer[i + line * scr->size_x].character = ' ';
-        scr->buffer[i + line * scr->size_x].style = scr->style;
+        scr->buffer[i + line * scr->size_x].attrs = scr->attrs;
     }
 }
 ,12 → 137,37
  * @param fg_color
  * @param bg_color
  */
-void screenbuffer_set_style(screenbuffer_t *scr, unsigned int fg_color, unsigned int bg_color)
+void screenbuffer_set_style(screenbuffer_t *scr, int style)
 {
-    scr->style.fg_color = fg_color;
-    scr->style.bg_color = bg_color;
+    scr->attrs.t = at_style;
+    scr->attrs.a.s.style = style;
 }
+/** Set new color.
+ * @param scr
+ * @param fg_color
+ * @param bg_color
+ */
+void screenbuffer_set_color(screenbuffer_t *scr, unsigned int fg_color, unsigned int bg_color, unsigned int flags)
+{
+    scr->attrs.t = at_idx;
+    scr->attrs.a.i.fg_color = fg_color;
+    scr->attrs.a.i.bg_color = bg_color;
+    scr->attrs.a.i.flags = flags;
+}
+/** Set new RGB color.
+ * @param scr
+ * @param fg_color
+ * @param bg_color
+ */
+void screenbuffer_set_rgb_color(screenbuffer_t *scr, unsigned int fg_color, unsigned int bg_color)
+{
+    scr->attrs.t = at_rgb;
+    scr->attrs.a.r.fg_color = fg_color;
+    scr->attrs.a.r.bg_color = bg_color;
+}
 /** @}
  */

 /branches/network/uspace/srv/console/gcons.c
 ,7 → 81,7
 static void vp_switch(int vp)
 {
-    async_msg_1(fbphone,FB_VIEWPORT_SWITCH, vp);
+    async_msg_1(fbphone, FB_VIEWPORT_SWITCH, vp);
 }
 /** Create view port */
 ,15 → 97,15
     async_msg_0(fbphone, FB_CLEAR);
 }
-static void set_style(int fgcolor, int bgcolor)
+static void set_rgb_color(int fgcolor, int bgcolor)
 {
-    async_msg_2(fbphone, FB_SET_STYLE, fgcolor, bgcolor);
+    async_msg_2(fbphone, FB_SET_RGB_COLOR, fgcolor, bgcolor);
 }
 /** Transparent putchar */
 static void tran_putch(char c, int row, int col)
 {
-    async_msg_3(fbphone, FB_TRANS_PUTCHAR, c, row, col);
+    async_msg_3(fbphone, FB_PUTCHAR, c, row, col);
 }
 /** Redraw the button showing state of a given console */
 ,10 → 189,10
         console_state[consnum] = CONS_DISCONNECTED_SEL;
     else
         console_state[consnum] = CONS_DISCONNECTED;
     if (active_console == KERNEL_CONSOLE)
         return;
     redraw_state(consnum);
     vp_switch(console_vp);
 }
 ,16 → 217,10
 /** Change to kernel console */
 void gcons_in_kernel(void)
 {
-    if (console_state[active_console] == CONS_DISCONNECTED_SEL)
-        console_state[active_console] = CONS_DISCONNECTED;
-    else
-        console_state[active_console] = CONS_IDLE;
-    redraw_state(active_console);
     if (animation != -1)
         async_msg_1(fbphone, FB_ANIM_STOP, animation);
-    active_console = KERNEL_CONSOLE; /* Set to kernel console */
+    active_console = KERNEL_CONSOLE;
     vp_switch(0);
 }
 ,8 → 244,8
  */
 void gcons_mouse_move(int dx, int dy)
 {
-    mouse_x = limit(mouse_x+dx, 0, xres);
-    mouse_y = limit(mouse_y+dy, 0, yres);
+    mouse_x = limit(mouse_x + dx, 0, xres);
+    mouse_y = limit(mouse_y + dy, 0, yres);
     async_msg_2(fbphone, FB_POINTER_MOVE, mouse_x, mouse_y);
 }
 ,7 → 252,7
 static int gcons_find_conbut(int x, int y)
 {
-    int status_start = STATUS_START + (xres - 800) / 2;;
+    int status_start = STATUS_START + (xres - 800) / 2;
     if (y < STATUS_TOP || y >= STATUS_TOP + STATUS_HEIGHT)
         return -1;
 ,10 → 262,10
     if (x >= status_start + (STATUS_WIDTH + STATUS_SPACE) * CONSOLE_COUNT)
         return -1;
-    if (((x - status_start) % (STATUS_WIDTH+STATUS_SPACE)) < STATUS_SPACE)
+    if (((x - status_start) % (STATUS_WIDTH + STATUS_SPACE)) < STATUS_SPACE)
         return -1;
-    return (x - status_start) / (STATUS_WIDTH+STATUS_SPACE);
+    return (x - status_start) / (STATUS_WIDTH + STATUS_SPACE);
 }
 /** Handle mouse click
 ,22 → 336,23
 extern int _binary_helenos_ppm_size;
 extern char _binary_nameic_ppm_start[0];
 extern int _binary_nameic_ppm_size;
-/** Redraws console graphics  */
-static void gcons_redraw_console(void)
+/** Redraws console graphics */
+void gcons_redraw_console(void)
 {
     int i;
     if (!use_gcons)
         return;
     vp_switch(0);
-    set_style(MAIN_COLOR, MAIN_COLOR);
+    set_rgb_color(MAIN_COLOR, MAIN_COLOR);
     clear();
     draw_pixmap(_binary_helenos_ppm_start,
         (size_t) &_binary_helenos_ppm_size, xres - 66, 2);
     draw_pixmap(_binary_nameic_ppm_start,
         (size_t) &_binary_nameic_ppm_size, 5, 17);
     for (i = 0; i < CONSOLE_COUNT; i++)
         redraw_state(i);
     vp_switch(console_vp);
 ,16 → 454,16
     int rc;
     int i;
     int status_start = STATUS_START;
     fbphone = phone;
     rc = async_req_0_2(phone, FB_GET_RESOLUTION, &xres, &yres);
     if (rc)
         return;
-    if (xres < 800 || yres < 600)
+    if ((xres < 800) || (yres < 600))
         return;
     /* create console viewport */
     /* Align width & height to character size */
     console_vp = vp_create(CONSOLE_MARGIN, CONSOLE_TOP,
 ,7 → 481,7
         if (cstatus_vp[i] < 0)
             return;
         vp_switch(cstatus_vp[i]);
-        set_style(0x202020, 0xffffff);
+        set_rgb_color(0x202020, 0xffffff);
     }
     /* Initialize icons */
 ,13 → 501,12
     ic_pixmaps[CONS_DISCONNECTED_SEL] = ic_pixmaps[CONS_SELECTED];
     make_anim();
     use_gcons = 1;
     console_state[0] = CONS_DISCONNECTED_SEL;
     console_state[KERNEL_CONSOLE] = CONS_KERNEL;
     gcons_redraw_console();
 }
 /** @}
  */

/branches/network/uspace/srv/console/gcons.h
36,6 → 36,7
#define _GCONS_H_

void gcons_init(int phone);
void gcons_redraw_console(void);
void gcons_change_console(int consnum);
void gcons_notify_char(int consnum);
void gcons_in_kernel(void);

 /branches/network/uspace/srv/console/screenbuffer.h
 ,28 → 35,52
 #ifndef __SCREENBUFFER_H__
 #define __SCREENBUFFER_H__
+#include <stdint.h>
 #define DEFAULT_FOREGROUND 0x0  /**< default console foreground color */
 #define DEFAULT_BACKGROUND 0xf0f0f0 /**< default console background color */
 typedef struct {
-    unsigned int bg_color;      /**< background color */
-    unsigned int fg_color;      /**< foreground color */
-} style_t;
+    uint8_t style;
+} attr_style_t;
+typedef struct {
+    uint8_t fg_color;
+    uint8_t bg_color;
+    uint8_t flags;
+} attr_idx_t;
+typedef struct {
+    uint32_t bg_color;      /**< background color */
+    uint32_t fg_color;      /**< foreground color */
+} attr_rgb_t;
+typedef struct {
+    enum {
+        at_style,
+        at_idx,
+        at_rgb
+    } t;
+    union {
+        attr_style_t s;
+        attr_idx_t i;
+        attr_rgb_t r;
+    } a;
+} attrs_t;
 /** One field on screen. It contain one character and its attributes. */
 typedef struct {
     char character;         /**< Character itself */
-    style_t style;          /**< Character`s attributes */
+    attrs_t attrs;          /**< Character`s attributes */
 } keyfield_t;
 /** Structure for buffering state of one virtual console.
  */
 typedef struct {
-    keyfield_t *buffer;         /**< Screen content - characters and its style. Used as cyclyc buffer. */
+    keyfield_t *buffer;         /**< Screen content - characters and their attributes. Used as a circular buffer. */
     unsigned int size_x, size_y;        /**< Number of columns and rows */
     unsigned int position_x, position_y;    /**< Coordinates of last printed character for determining cursor position */
-    style_t style;              /**< Current style */
+    attrs_t attrs;              /**< Current attributes. */
     unsigned int top_line;          /**< Points to buffer[][] line that will be printed at screen as the first line */
     unsigned char is_cursor_visible;    /**< Cursor state - default is visible */
 } screenbuffer_t;
 ,14 → 96,23
     return scr->buffer + x + ((y + scr->top_line) % scr->size_y) * scr->size_x;
 }
-/** Compares two styles.
+/** Compares two sets of attributes.
  * @param s1 first style
  * @param s2 second style
  * @return nonzero on equality
  */
-static inline int style_same(style_t s1, style_t s2)
+static inline int attrs_same(attrs_t a1, attrs_t a2)
 {
-    return s1.fg_color == s2.fg_color && s1.bg_color == s2.bg_color;
+    if (a1.t != a2.t) return 0;
+    switch (a1.t) {
+    case at_style: return a1.a.s.style == a2.a.s.style;
+    case at_idx: return a1.a.i.fg_color == a2.a.i.fg_color &&
+        a1.a.i.bg_color == a2.a.i.bg_color &&
+        a1.a.i.flags == a2.a.i.flags;
+    case at_rgb: return a1.a.r.fg_color == a2.a.r.fg_color &&
+        a1.a.r.bg_color == a2.a.r.bg_color;
+    }
 }
 ,7 → 123,11
 void screenbuffer_clear_line(screenbuffer_t *scr, unsigned int line);
 void screenbuffer_copy_buffer(screenbuffer_t *scr, keyfield_t *dest);
 void screenbuffer_goto(screenbuffer_t *scr, unsigned int x, unsigned int y);
-void screenbuffer_set_style(screenbuffer_t *scr, unsigned int fg_color, unsigned int bg_color);
+void screenbuffer_set_style(screenbuffer_t *scr, int style);
+void screenbuffer_set_color(screenbuffer_t *scr, unsigned int fg_color,
+    unsigned int bg_color, unsigned int attr);
+void screenbuffer_set_rgb_color(screenbuffer_t *scr, unsigned int fg_color,
+    unsigned int bg_color);
 #endif

 /branches/network/uspace/srv/console/Makefile
 ,8 → 31,9
 LIBC_PREFIX = ../../lib/libc
 SOFTINT_PREFIX = ../../lib/softint
-include $(LIBC_PREFIX)/Makefile.toolchain
+include $(LIBC_PREFIX)/Makefile.toolchain
 CFLAGS += -I. -I../kbd/include -I../fb
 LIBS = $(LIBC_PREFIX)/libc.a
 ,6 → 58,8
             $(addsuffix .o,$(basename $(IMAGES)))
 ARCH_OBJECTS := $(addsuffix .o,$(basename $(ARCH_SOURCES)))
+OBJECTS := $(GENERIC_OBJECTS) $(ARCH_OBJECTS)
 .PHONY: all clean depend disasm
 all: $(OUTPUT) $(OUTPUT).disasm
 ,13 → 67,13
 -include Makefile.depend
 clean:
-    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend
+    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend $(OBJECTS)
 depend:
     $(CC) $(DEFS) $(CFLAGS) -M $(SOURCES) > Makefile.depend
-$(OUTPUT): $(ARCH_OBJECTS) $(GENERIC_OBJECTS) $(LIBS)
-    $(LD) -T $(LIBC_PREFIX)/arch/$(ARCH)/_link.ld $(GENERIC_OBJECTS) $(ARCH_OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+$(OUTPUT): $(OBJECTS) $(LIBS)
+    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
 disasm: $(OUTPUT).disasm

 /branches/network/uspace/srv/rd/rd.c
 ,12 → 188,10
     int phone;
     ipcarg_t callback_phonehash;
-    phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP, DEVMAP_DRIVER, 0);
-    while (phone < 0) {
-        usleep(10000);
-        phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP,
-            DEVMAP_DRIVER, 0);
+    phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAP, DEVMAP_DRIVER, 0);
+    if (phone < 0) {
+        printf(NAME ": Failed to connect to device mapper\n");
+        return -1;
     }
     req = async_send_2(phone, DEVMAP_DRIVER_REGISTER, 0, 0, &answer);
 ,7 → 255,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/network/uspace/srv/rd/Makefile
 ,8 → 29,10
 ## Setup toolchain
 #
 LIBC_PREFIX = ../../lib/libc
 SOFTINT_PREFIX = ../../lib/softint
 include $(LIBC_PREFIX)/Makefile.toolchain
 LIBS = $(LIBC_PREFIX)/libc.a
 ,13 → 53,13
 -include Makefile.depend
 clean:
-    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend
+    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend $(OBJECTS)
 depend:
     $(CC) $(DEFS) $(CFLAGS) -M $(SOURCES) > Makefile.depend
 $(OUTPUT): $(OBJECTS) $(LIBS)
-    $(LD) -T $(LIBC_PREFIX)/arch/$(ARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
 disasm: $(OUTPUT).disasm

 /branches/network/uspace/srv/loader/main.c
 ,12 → 27,12
  */
 /** @addtogroup loader
- * @brief   Loads and runs programs from VFS.
+ * @brief Loads and runs programs from VFS.
  * @{
- */
+ */
 /**
  * @file
- * @brief   Loads and runs programs from VFS.
+ * @brief Loads and runs programs from VFS.
  *
  * The program loader is a special init binary. Its image is used
  * to create a new task upon a @c task_spawn syscall. The syscall
 ,9 → 46,11
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
+#include <bool.h>
 #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>
 ,11 → 60,7
 #include <elf.h>
 #include <elf_load.h>
-/**
- * Bias used for loading the dynamic linker. This will be soon replaced
- * by automatic placement.
- */
-#define RTLD_BIAS 0x80000
+#define DPRINTF(...)
 /** Pathname of the file that will be loaded */
 static char *pathname = NULL;
 ,6 → 75,36
 /** Buffer holding all arguments */
 static char *arg_buf = NULL;
+static elf_info_t prog_info;
+static elf_info_t interp_info;
+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)
+{
+    ipc_callid_t callid;
+    task_id_t task_id;
+    size_t len;
+    task_id = task_get_id();
+    if (!ipc_data_read_receive(&callid, &len)) {
+        ipc_answer_0(callid, EINVAL);
+        ipc_answer_0(rid, EINVAL);
+        return;
+    }
+    if (len > sizeof(task_id))
+        len = sizeof(task_id);
+    ipc_data_read_finalize(callid, &task_id, len);
+    ipc_answer_0(rid, EOK);
+}
 /** Receive a call setting pathname of the program to execute.
  *
  * @param rid
 ,13 → 115,13
     ipc_callid_t callid;
     size_t len;
     char *name_buf;
     if (!ipc_data_write_receive(&callid, &len)) {
         ipc_answer_0(callid, EINVAL);
         ipc_answer_0(rid, EINVAL);
         return;
     }
     name_buf = malloc(len + 1);
     if (!name_buf) {
         ipc_answer_0(callid, ENOMEM);
 ,15 → 128,15
         ipc_answer_0(rid, ENOMEM);
         return;
     }
     ipc_data_write_finalize(callid, name_buf, len);
     ipc_answer_0(rid, EOK);
     if (pathname != NULL) {
         free(pathname);
         pathname = NULL;
     }
     name_buf[len] = '\0';
     pathname = name_buf;
 }
 ,23 → 152,23
     size_t buf_len, arg_len;
     char *p;
     int n;
     if (!ipc_data_write_receive(&callid, &buf_len)) {
         ipc_answer_0(callid, EINVAL);
         ipc_answer_0(rid, EINVAL);
         return;
     }
     if (arg_buf != NULL) {
         free(arg_buf);
         arg_buf = NULL;
     }
     if (argv != NULL) {
         free(argv);
         argv = NULL;
     }
     arg_buf = malloc(buf_len + 1);
     if (!arg_buf) {
         ipc_answer_0(callid, ENOMEM);
 ,12 → 175,12
         ipc_answer_0(rid, ENOMEM);
         return;
     }
     ipc_data_write_finalize(callid, arg_buf, buf_len);
     ipc_answer_0(rid, EOK);
     arg_buf[buf_len] = '\0';
     /*
      * Count number of arguments
      */
 ,10 → 191,10
         p = p + arg_len + 1;
         ++n;
     }
     /* Allocate argv */
     argv = malloc((n + 1) * sizeof(char *));
     if (argv == NULL) {
         free(arg_buf);
         ipc_answer_0(callid, ENOMEM);
 ,7 → 201,7
         ipc_answer_0(rid, ENOMEM);
         return;
     }
     /*
      * Fill argv with argument pointers
      */
 ,78 → 209,91
     n = 0;
     while (p < arg_buf + buf_len) {
         argv[n] = p;
         arg_len = strlen(p);
         p = p + arg_len + 1;
         ++n;
     }
     argc = n;
     argv[n] = NULL;
 }
-/** Load and run the previously selected program.
+/** Load the previously selected program.
  *
  * @param rid
  * @param request
  * @return 0 on success, !0 on error.
  */
-static int loader_run(ipc_callid_t rid, ipc_call_t *request)
+static int loader_load(ipc_callid_t rid, ipc_call_t *request)
 {
     int rc;
-    elf_info_t prog_info;
-    elf_info_t interp_info;
-//  printf("Load program '%s'\n", pathname);
     rc = elf_load_file(pathname, 0, &prog_info);
     if (rc < 0) {
-        printf("failed to load program\n");
+        DPRINTF("Failed to load executable '%s'.\n", pathname);
         ipc_answer_0(rid, EINVAL);
         return 1;
     }
-//  printf("Create PCB\n");
     elf_create_pcb(&prog_info, &pcb);
     pcb.argc = argc;
     pcb.argv = argv;
     if (prog_info.interp == NULL) {
         /* Statically linked program */
-//      printf("Run statically linked program\n");
-//      printf("entry point: 0x%llx\n", prog_info.entry);
+        is_dyn_linked = false;
         ipc_answer_0(rid, EOK);
-        close_console();
-        elf_run(&prog_info, &pcb);
         return 0;
     }
-    printf("Load dynamic linker '%s'\n", prog_info.interp);
-    rc = elf_load_file("/rtld.so", RTLD_BIAS, &interp_info);
+    rc = elf_load_file(prog_info.interp, 0, &interp_info);
     if (rc < 0) {
-        printf("failed to load dynamic linker\n");
+        DPRINTF("Failed to load interpreter '%s.'\n",
+            prog_info.interp);
         ipc_answer_0(rid, EINVAL);
         return 1;
     }
+    is_dyn_linked = true;
+    ipc_answer_0(rid, EOK);
+    return 0;
+}
-    /*
-     * Provide dynamic linker with some useful data
-     */
-    pcb.rtld_dynamic = interp_info.dynamic;
-    pcb.rtld_bias = RTLD_BIAS;
-    printf("run dynamic linker\n");
-    printf("entry point: 0x%llx\n", interp_info.entry);
-    close_console();
+/** Run the previously loaded program.
+ *
+ * @param rid
+ * @param request
+ * @return 0 on success, !0 on error.
+ */
+static void loader_run(ipc_callid_t rid, ipc_call_t *request)
+{
+    const char *cp;
+    /* Set the task name. */
+    cp = strrchr(pathname, '/');
+    cp = (cp == NULL) ? pathname : (cp + 1);
+    task_set_name(cp);
+    if (is_dyn_linked == true) {
+        /* Dynamically linked program */
+        DPRINTF("Run ELF interpreter.\n");
+        DPRINTF("Entry point: 0x%lx\n", interp_info.entry);
+        close_console();
+        ipc_answer_0(rid, EOK);
+        elf_run(&interp_info, &pcb);
+    } else {
+        /* Statically linked program */
+        close_console();
+        ipc_answer_0(rid, EOK);
+        elf_run(&prog_info, &pcb);
+    }
-    ipc_answer_0(rid, EOK);
-    elf_run(&interp_info, &pcb);
     /* Not reached */
-    return 0;
 }
 /** Handle loader connection.
 ,24 → 306,43
     ipc_callid_t callid;
     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;
+    (void) iid;
+    (void) icall;
     while (1) {
         callid = async_get_call(&call);
-//      printf("received call from phone %d, method=%d\n",
-//          call.in_phone_hash, IPC_GET_METHOD(call));
         switch (IPC_GET_METHOD(call)) {
+        case IPC_M_PHONE_HUNGUP:
+            exit(0);
+        case LOADER_GET_TASKID:
+            loader_get_taskid(callid, &call);
+            continue;
         case LOADER_SET_PATHNAME:
             loader_set_pathname(callid, &call);
             continue;
         case LOADER_SET_ARGS:
             loader_set_args(callid, &call);
+            continue;
+        case LOADER_LOAD:
+            loader_load(callid, &call);
+            continue;
         case LOADER_RUN:
             loader_run(callid, &call);
-            exit(0);
-            continue;
+            /* Not reached */
         default:
             retval = ENOENT;
             break;
 ,7 → 349,7
         }
         if ((callid & IPC_CALLID_NOTIFICATION) == 0 &&
             IPC_GET_METHOD(call) != IPC_M_PHONE_HUNGUP) {
-            printf("responding EINVAL to method %d\n",
+            DPRINTF("Responding EINVAL to method %d.\n",
                 IPC_GET_METHOD(call));
             ipc_answer_0(callid, EINVAL);
         }
 ,31 → 360,20
  */
 int main(int argc, char *argv[])
 {
-    ipc_callid_t callid;
-    ipc_call_t call;
-    ipcarg_t phone_hash;
-    /* The first call only communicates the incoming phone hash */
-    callid = ipc_wait_for_call(&call);
-    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);
+    ipcarg_t phonead;
+    connected = false;
+    /* Set a handler of incomming connections. */
+    async_set_client_connection(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/network/uspace/srv/loader/elf_load.c
 ,6 → 57,8
 #include "elf_load.h"
 #include "arch.h"
+#define DPRINTF(...)
 static char *error_codes[] = {
     "no error",
     "invalid image",
 ,11 → 108,9
     int fd;
     int rc;
-//  printf("open and read '%s'...\n", file_name);
     fd = open(file_name, O_RDONLY);
     if (fd < 0) {
-        printf("failed opening file\n");
+        DPRINTF("failed opening file\n");
         return -1;
     }
 ,19 → 171,18
     rc = my_read(elf->fd, header, sizeof(elf_header_t));
     if (rc < 0) {
-        printf("read error\n");
+        DPRINTF("Read error.\n");
         return EE_INVALID;
     }
     elf->header = header;
-//  printf("ELF-load:");
     /* Identify ELF */
     if (header->e_ident[EI_MAG0] != ELFMAG0 ||
         header->e_ident[EI_MAG1] != ELFMAG1 ||
         header->e_ident[EI_MAG2] != ELFMAG2 ||
         header->e_ident[EI_MAG3] != ELFMAG3) {
-        printf("invalid header\n");
+        DPRINTF("Invalid header.\n");
         return EE_INVALID;
     }
 ,18 → 192,18
         header->e_ident[EI_VERSION] != EV_CURRENT ||
         header->e_version != EV_CURRENT ||
         header->e_ident[EI_CLASS] != ELF_CLASS) {
-        printf("incompatible data/version/class\n");
+        DPRINTF("Incompatible data/version/class.\n");
         return EE_INCOMPATIBLE;
     }
     if (header->e_phentsize != sizeof(elf_segment_header_t)) {
-        printf("e_phentsize:%d != %d\n", header->e_phentsize,
+        DPRINTF("e_phentsize:%d != %d\n", header->e_phentsize,
             sizeof(elf_segment_header_t));
         return EE_INCOMPATIBLE;
     }
     if (header->e_shentsize != sizeof(elf_section_header_t)) {
-        printf("e_shentsize:%d != %d\n", header->e_shentsize,
+        DPRINTF("e_shentsize:%d != %d\n", header->e_shentsize,
             sizeof(elf_section_header_t));
         return EE_INCOMPATIBLE;
     }
 ,23 → 210,19
     /* Check if the object type is supported. */
     if (header->e_type != ET_EXEC && header->e_type != ET_DYN) {
-        printf("Object type %d is not supported\n", header->e_type);
+        DPRINTF("Object type %d is not supported\n", header->e_type);
         return EE_UNSUPPORTED;
     }
     /* Shared objects can be loaded with a bias */
-//  printf("Object type: %d\n", header->e_type);
     if (header->e_type == ET_DYN)
         elf->bias = so_bias;
     else
         elf->bias = 0;
-//  printf("Bias set to 0x%x\n", elf->bias);
     elf->info->interp = NULL;
     elf->info->dynamic = NULL;
-//  printf("parse segments\n");
     /* Walk through all segment headers and process them. */
     for (i = 0; i < header->e_phnum; i++) {
         elf_segment_header_t segment_hdr;
 ,7 → 234,7
         rc = my_read(elf->fd, &segment_hdr,
             sizeof(elf_segment_header_t));
         if (rc < 0) {
-            printf("read error\n");
+            DPRINTF("Read error.\n");
             return EE_INVALID;
         }
 ,7 → 243,7
             return rc;
     }
-//  printf("parse sections\n");
+    DPRINTF("Parse sections.\n");
     /* Inspect all section headers and proccess them. */
     for (i = 0; i < header->e_shnum; i++) {
 ,7 → 256,7
         rc = my_read(elf->fd, &section_hdr,
             sizeof(elf_section_header_t));
         if (rc < 0) {
-            printf("read error\n");
+            DPRINTF("Read error.\n");
             return EE_INVALID;
         }
 ,7 → 268,7
     elf->info->entry =
         (entry_point_t)((uint8_t *)header->e_entry + elf->bias);
-//  printf("done\n");
+    DPRINTF("Done.\n");
     return EE_OK;
 }
 ,7 → 311,7
     case PT_LOPROC:
     case PT_HIPROC:
     default:
-        printf("segment p_type %d unknown\n", entry->p_type);
+        DPRINTF("Segment p_type %d unknown.\n", entry->p_type);
         return EE_UNSUPPORTED;
         break;
     }
 ,8 → 334,8
     size_t mem_sz;
     int rc;
-//  printf("load segment at addr 0x%x, size 0x%x\n", entry->p_vaddr,
-//      entry->p_memsz);
+    DPRINTF("Load segment at addr 0x%x, size 0x%x\n", entry->p_vaddr,
+        entry->p_memsz);
     bias = elf->bias;
 ,7 → 342,7
     if (entry->p_align > 1) {
         if ((entry->p_offset % entry->p_align) !=
             (entry->p_vaddr % entry->p_align)) {
-            printf("align check 1 failed offset%%align=%d, "
+            DPRINTF("Align check 1 failed offset%%align=%d, "
                 "vaddr%%align=%d\n",
                 entry->p_offset % entry->p_align,
                 entry->p_vaddr % entry->p_align
 ,8 → 364,8
     base = ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE);
     mem_sz = entry->p_memsz + (entry->p_vaddr - base);
-//  printf("map to p_vaddr=0x%x-0x%x...\n", entry->p_vaddr + bias,
-//  entry->p_vaddr + bias + ALIGN_UP(entry->p_memsz, PAGE_SIZE));
+    DPRINTF("Map to p_vaddr=0x%x-0x%x.\n", entry->p_vaddr + bias,
+    entry->p_vaddr + bias + ALIGN_UP(entry->p_memsz, PAGE_SIZE));
     /*
      * For the course of loading, the area needs to be readable
 ,17 → 374,16
     a = as_area_create((uint8_t *)base + bias, mem_sz,
         AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE);
     if (a == (void *)(-1)) {
-        printf("memory mapping failed\n");
+        DPRINTF("Memory mapping failed.\n");
         return EE_MEMORY;
     }
-//  printf("as_area_create(0x%lx, 0x%x, %d) -> 0x%lx\n",
-//      entry->p_vaddr+bias, entry->p_memsz, flags, (uintptr_t)a);
+    DPRINTF("as_area_create(0x%lx, 0x%x, %d) -> 0x%lx\n",
+        entry->p_vaddr+bias, entry->p_memsz, flags, (uintptr_t)a);
     /*
      * Load segment data
      */
-//  printf("seek to %d\n", entry->p_offset);
     rc = lseek(elf->fd, entry->p_offset, SEEK_SET);
     if (rc < 0) {
         printf("seek error\n");
 ,11 → 390,10
         return EE_INVALID;
     }
-//  printf("read 0x%x bytes to address 0x%x\n", entry->p_filesz, entry->p_vaddr+bias);
 /*  rc = read(fd, (void *)(entry->p_vaddr + bias), entry->p_filesz);
     if (rc < 0) { printf("read error\n"); return EE_INVALID; }*/
-    /* Long reads are not possible yet. Load segment picewise */
+    /* Long reads are not possible yet. Load segment piecewise. */
     unsigned left, now;
     uint8_t *dp;
 ,12 → 405,10
         now = 16384;
         if (now > left) now = left;
-//      printf("read %d...", now);
         rc = my_read(elf->fd, dp, now);
-//      printf("->%d\n", rc);
         if (rc < 0) {
-            printf("read error\n");
+            DPRINTF("Read error.\n");
             return EE_INVALID;
         }
 ,10 → 416,9
         dp += now;
     }
-//  printf("set area flags to %d\n", flags);
     rc = as_area_change_flags((uint8_t *)entry->p_vaddr + bias, flags);
     if (rc != 0) {
-        printf("failed to set memory area flags\n");
+        DPRINTF("Failed to set memory area flags.\n");
         return EE_MEMORY;
     }
 ,7 → 455,7
         /* Record pointer to dynamic section into info structure */
         elf->info->dynamic =
             (void *)((uint8_t *)entry->sh_addr + elf->bias);
-        printf("dynamic section found at 0x%x\n",
+        DPRINTF("Dynamic section found at 0x%x.\n",
             (uintptr_t)elf->info->dynamic);
         break;
     default:

 /branches/network/uspace/srv/loader/Makefile
 ,30 → 27,19
 # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
-include ../../../version
-include ../../Makefile.config
 ## Setup toolchain
 #
 LIBC_PREFIX = ../../lib/libc
 SOFTINT_PREFIX = ../../lib/softint
 include $(LIBC_PREFIX)/Makefile.toolchain
-include arch/$(ARCH)/Makefile.inc
+include arch/$(UARCH)/Makefile.inc
 CFLAGS += -Iinclude
 LIBS = $(LIBC_PREFIX)/libc.a $(SOFTINT_PREFIX)/libsoftint.a
-DEFS += -DRELEASE=\"$(RELEASE)\"
-ifdef REVISION
-    DEFS += "-DREVISION=\"$(REVISION)\""
-endif
-ifdef TIMESTAMP
-    DEFS += "-DTIMESTAMP=\"$(TIMESTAMP)\""
-endif
 ## Sources
 #
 ,18 → 59,18
 -include Makefile.depend
 clean:
-    -rm -f $(OUTPUT) $(OBJECTS) $(OUTPUT).map $(OUTPUT).disasm arch/$(ARCH)/_link.ld Makefile.depend
+    -rm -f $(OUTPUT) $(OBJECTS) $(OUTPUT).map $(OUTPUT).disasm arch/$(UARCH)/_link.ld Makefile.depend
 depend:
     $(CC) $(DEFS) $(CFLAGS) -M $(SOURCES) > Makefile.depend
-$(OUTPUT): $(OBJECTS) $(LIBS) arch/$(ARCH)/_link.ld
-    $(LD) -T arch/$(ARCH)/_link.ld $(LFLAGS) $(OBJECTS) $(LIBS) -o $@ -Map $(OUTPUT).map
+$(OUTPUT): $(OBJECTS) $(LIBS) arch/$(UARCH)/_link.ld
+    $(LD) -T arch/$(UARCH)/_link.ld $(LFLAGS) $(OBJECTS) $(LIBS) -o $@ -Map $(OUTPUT).map
 disasm:
     $(OBJDUMP) -d $(OUTPUT) >$(OUTPUT).disasm
-arch/$(ARCH)/_link.ld: arch/$(ARCH)/_link.ld.in
+arch/$(UARCH)/_link.ld: arch/$(UARCH)/_link.ld.in
     $(CC) $(DEFS) $(CFLAGS) -DLIBC_PREFIX=$(LIBC_PREFIX) -E -x c $< | grep -v "^\#" > $@
 %.o: %.S

/branches/network/uspace/srv/loader/arch/sparc64/_link.ld.in
1,4 → 1,4
STARTUP(LIBC_PREFIX/arch/ARCH/src/entry.o)
STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
ENTRY(__entry)

PHDRS {

/branches/network/uspace/srv/loader/arch/sparc64/Makefile.inc
27,4 → 27,4
#

CFLAGS += -D__64_BITS__
ARCH_SOURCES := arch/$(ARCH)/sparc64.s
ARCH_SOURCES := arch/$(UARCH)/sparc64.s

 /branches/network/uspace/srv/loader/arch/ia64/_link.ld.in
 ,4 → 1,4
-STARTUP(LIBC_PREFIX/arch/ARCH/src/entry.o)
+STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
 ENTRY(__entry)
 PHDRS {
 ,15 → 12,10
         *(.interp);
     } :interp
-    . = 0x00084000 + SIZEOF_HEADERS;
+    /* On Itanium code sections must be aligned to 16 bytes. */
+    . = ALIGN(0x800000000 + SIZEOF_HEADERS, 16);
     .init : {
-        LONG(0);
-        LONG(0);
-        LONG(0);
-        LONG(0);
-        LONG(0);
-        LONG(0);
         *(.init);
     } : text
     .text : {

/branches/network/uspace/srv/loader/arch/ia64/Makefile.inc
27,5 → 27,5
#

CFLAGS += -D__64_BITS__
ARCH_SOURCES := arch/$(ARCH)/ia64.s
ARCH_SOURCES := arch/$(UARCH)/ia64.s
AFLAGS += -xexplicit

 /branches/network/uspace/srv/loader/arch/arm32/_link.ld.in
 ,8 → 1,8
-/*
+/*
  * The only difference from _link.ld.in for regular statically-linked apps
  * is the base address.
  */
-STARTUP(LIBC_PREFIX/arch/ARCH/src/entry.o)
+STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
 ENTRY(__entry)
 PHDRS {

/branches/network/uspace/srv/loader/arch/arm32/Makefile.inc
27,4 → 27,4
#

CFLAGS += -D__32_BITS__
ARCH_SOURCES := arch/$(ARCH)/arm32.s
ARCH_SOURCES := arch/$(UARCH)/arm32.s

/branches/network/uspace/srv/loader/arch/mips32eb
0,0 → 1,0
link mips32
Property changes:
Added: svn:special
+*
\ No newline at end of property

 /branches/network/uspace/srv/loader/arch/ppc32/_link.ld.in
 ,8 → 1,8
-/*
+/*
  * The only difference from _link.ld.in for regular statically-linked apps
  * is the base address.
  */
-STARTUP(LIBC_PREFIX/arch/ARCH/src/entry.o)
+STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
 ENTRY(__entry)
 PHDRS {

/branches/network/uspace/srv/loader/arch/ppc32/Makefile.inc
27,4 → 27,4
#

CFLAGS += -D__32_BITS__
ARCH_SOURCES := arch/$(ARCH)/ppc32.s
ARCH_SOURCES := arch/$(UARCH)/ppc32.s

/branches/network/uspace/srv/loader/arch/ppc32/ppc32.s
36,5 → 36,5
# Jump to a program entry point
program_run:
mtctr %r3
mr %r3, %r4 # Pass pcb to the entry point in %r3
mr %r6, %r4 # Pass pcb to the entry point in %r6
bctr

/branches/network/uspace/srv/loader/arch/amd64/_link.ld.in
1,4 → 1,4
STARTUP(LIBC_PREFIX/arch/ARCH/src/entry.o)
STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
ENTRY(__entry)

PHDRS {

/branches/network/uspace/srv/loader/arch/amd64/Makefile.inc
27,4 → 27,4
#

CFLAGS += -D__64_BITS__
ARCH_SOURCES := arch/$(ARCH)/amd64.s
ARCH_SOURCES := arch/$(UARCH)/amd64.s

 /branches/network/uspace/srv/loader/arch/mips32/_link.ld.in
 ,8 → 1,8
-/*
+/*
  * The only difference from _link.ld.in for regular statically-linked apps
  * is the base address.
  */
-STARTUP(LIBC_PREFIX/arch/ARCH/src/entry.o)
+STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
 ENTRY(__entry)
 PHDRS {

/branches/network/uspace/srv/loader/arch/mips32/Makefile.inc
27,4 → 27,4
#

CFLAGS += -D__32_BITS__
ARCH_SOURCES := arch/$(ARCH)/mips32.s
ARCH_SOURCES := arch/$(UARCH)/mips32.s

 /branches/network/uspace/srv/loader/arch/ia32/_link.ld.in
 ,8 → 1,8
-/*
+/*
  * The difference from _link.ld.in for regular statically-linked apps
  * is the base address and the special interp section.
  */
-STARTUP(LIBC_PREFIX/arch/ARCH/src/entry.o)
+STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
 ENTRY(__entry)
 PHDRS {

/branches/network/uspace/srv/loader/arch/ia32/Makefile.inc
27,4 → 27,4
#

CFLAGS += -D__32_BITS__
ARCH_SOURCES := arch/$(ARCH)/ia32.s
ARCH_SOURCES := arch/$(UARCH)/ia32.s

 /branches/network/uspace/srv/net/nil/eth/eth.c
 ,8 → 123,8
 int eth_send_message( device_id_t device_id, packet_t packet, services_t sender );
 int eth_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count );
 void    eth_receiver( ipc_callid_t iid, ipc_call_t * icall );
-eth_proto_ref   eth_proccess_packet( packet_t packet );
-int eth_prepare_packet( packet_t packet, uint8_t * src_addr, int ethertype );
+eth_proto_ref   eth_proccess_packet( int dummy, packet_t packet );
+int eth_prepare_packet( int dummy, packet_t packet, uint8_t * src_addr, int ethertype );
 int eth_initialize( void ){
     ERROR_DECLARE;
 ,6 → 173,8
         device->device_id = device_id;
         device->service = service;
         device->mtu = mtu;
+        // TODO get dummy setting
+        device->dummy = 0;
         // bind the device driver
         device->phone = bind_service( device->service, device->device_id, SERVICE_ETHERNET, 0, eth_receiver );
         // get hardware address
 ,7 → 206,7
     return EOK;
 }
-eth_proto_ref eth_proccess_packet( packet_t packet ){
+eth_proto_ref eth_proccess_packet( int dummy, packet_t packet ){
     ERROR_DECLARE;
     eth_header_ex_ref   header;
 ,6 → 217,9
     eth_fcs_ref         fcs;
     length = packet_get_data_length( packet );
+    if( dummy ){
+        packet_trim( packet, sizeof( eth_preamble_t ), 0 );
+    }
     if( length <= sizeof( eth_header_t ) + ETH_MIN_CONTENT + ETH_SUFFIX ) return NULL;
     header = ( eth_header_ex_ref ) packet_get_data( packet );
     type = ntohs( header->header.ethertype );
 ,9 → 251,10
         // invalid length/type, should not occurr
         return NULL;
     }
-    // TODO compute crc with fcs to erase?
-    if(( ~ compute_crc32( ~ 0, & header->header.dest, ((( void * ) fcs ) - (( void * ) & header->header.dest )) * 8 )) != ntohl( * fcs )){
-        return NULL;
+    if( dummy ){
+        if(( ~ compute_crc32( ~ 0, & header->header.dest, ((( void * ) fcs ) - (( void * ) & header->header.dest )) * 8 )) != ntohl( * fcs )){
+            return NULL;
+        }
     }
     if( ERROR_OCCURRED( packet_set_addr( packet, header->header.src, header->header.dest, ETH_ADDR ))
     || ERROR_OCCURRED( packet_trim( packet, prefix, suffix ))){
 ,11 → 266,21
 int eth_receive_message( device_id_t device_id, packet_t packet ){
     eth_proto_ref   proto;
     packet_t        next;
+    eth_device_ref  device;
+    int             dummy;
+    rwlock_read_lock( & eth_globals.devices_lock );
+    device = eth_devices_find( & eth_globals.devices, device_id );
+    if( ! device ){
+        rwlock_read_unlock( & eth_globals.devices_lock );
+        return ENOENT;
+    }
+    dummy = device->dummy;
+    rwlock_read_unlock( & eth_globals.devices_lock );
     rwlock_read_lock( & eth_globals.protos_lock );
     do{
         next = pq_detach( packet );
-        proto = eth_proccess_packet( packet );
+        proto = eth_proccess_packet( dummy, packet );
         if( proto ){
             async_msg_2( proto->phone, NET_IL_RECEIVED, device_id, packet_get_id( packet ));
         }else{
 ,7 → 363,7
     return EOK;
 }
-int eth_prepare_packet( packet_t packet, uint8_t * src_addr, int ethertype ){
+int eth_prepare_packet( int dummy, packet_t packet, uint8_t * src_addr, int ethertype ){
     eth_header_ex_ref   header;
     eth_fcs_ref         fcs;
     uint8_t *           src;
 ,11 → 371,16
     int                 length;
     int                 i;
     void *              padding;
+    eth_preamble_ref    preamble;
+    if( dummy ){
+        preamble = PACKET_PREFIX( packet, eth_preamble_t );
+        if( ! preamble ) return ENOMEM;
+        for( i = 0; i < 7; ++ i ) preamble->preamble[ i ] = ETH_PREAMBLE;
+        preamble->sfd = ETH_SFD;
+    }
     header = PACKET_PREFIX( packet, eth_header_ex_t );
     if( ! header ) return ENOMEM;
-    for( i = 0; i < 7; ++ i ) header->header.preamble[ i ] = ETH_PREAMBLE;
-    header->header.sfd = ETH_SFD;
     length = packet_get_addr( packet, & src, & dest );
     if( length < 0 ) return length;
     if( length < ETH_ADDR ) return EINVAL;
 ,9 → 399,11
     header->lsap.ctrl = 0;
     for( i = 0; i < 3; ++ i ) header->snap.proto[ i ] = 0;
     header->snap.ethertype = ethertype;
-    fcs = PACKET_SUFFIX( packet, eth_fcs_t );
-    if( ! fcs ) return ENOMEM;
-    * fcs = htonl( ~ compute_crc32( ~ 0, & header->header.dest, ((( void * ) fcs ) - (( void * ) & header->header.dest )) * 8 ));
+    if( dummy ){
+        fcs = PACKET_SUFFIX( packet, eth_fcs_t );
+        if( ! fcs ) return ENOMEM;
+        * fcs = htonl( ~ compute_crc32( ~ 0, & header->header.dest, ((( void * ) fcs ) - (( void * ) & header->header.dest )) * 8 ));
+    }
     return EOK;
 }
 ,7 → 429,7
     // proccess packet queue
     next = packet;
     do{
-        if( ERROR_OCCURRED( eth_prepare_packet( next, ( uint8_t * ) device->addr->value, ethertype ))){
+        if( ERROR_OCCURRED( eth_prepare_packet( device->dummy, next, ( uint8_t * ) device->addr->value, ethertype ))){
             // release invalid packet
             tmp = pq_detach( next );
             packet_release( eth_globals.networking_phone, packet_get_id( next ));

 /branches/network/uspace/srv/net/nil/eth/eth.h
 ,6 → 97,10
     /** Maximal transmission unit.
      */
     size_t              mtu;
+    /** Dummy device.
+     *  Preamble and FCS are mandatory part of the packets.
+     */
+    int                 dummy;
     /** Actual device hardware address.
      */
     measured_string_ref addr;

 /branches/network/uspace/srv/net/nil/eth/eth_header.h
 ,6 → 76,16
  */
 typedef eth_header_snap_t *     eth_header_snap_ref;
+/** Type definition of the Ethernet header preamble.
+ *  @see preamble
+ */
+typedef struct eth_preamble eth_preamble_t;
+/** Type definition of the Ethernet header preamble pointer.
+ *  @see eth_preamble
+ */
+typedef eth_preamble_t *        eth_preamble_ref;
 /** Type definition of the Ethernet header.
  *  @see eth_header
  */
 ,9 → 125,10
     uint16_t    ethertype;
 };
-/** Ethernet header.
+/** Ethernet header preamble.
+ *  Used for dummy devices.
  */
-struct eth_header{
+struct eth_preamble{
     /** Controlling preamble used for the frame transmission synchronization.
      *  All should be set to ETH_PREAMBLE.
      */
 ,6 → 137,11
      *  Should be set to ETH_SFD.
      */
     uint8_t     sfd;
+};
+/** Ethernet header.
+ */
+struct eth_header{
     /** Destination host Ethernet address (MAC address).
      */
     uint8_t     dest[ ETH_ADDR ];

/branches/network/uspace/srv/net/Makefile
30,6 → 30,7

DIRS = \
netif/lo \
netif/dp8390 \
networking \
networking/startup

 /branches/network/uspace/srv/fb/sgcn.h
 ,0 → 1,46
+/*
+ * 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.
+ */
+/** @defgroup sgcnfb SGCN
+ * @brief   userland driver of the Serengeti console output
+ * @{
+ */
+/** @file
+ */
+#ifndef FB_SGCN_H_
+#define FB_SGCN_H_
+int sgcn_init(void);
+#endif
+/**
+ * @}
+ */

 /branches/network/uspace/srv/fb/serial_console.c
 ,0 → 1,381
+/*
+ * Copyright (c) 2006 Ondrej Palkovsky
+ * Copyright (c) 2008 Martin Decky
+ * 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.
+ */
+/**
+ * @defgroup serial Serial console
+ * @brief    Serial console services (putc, puts, clear screen, cursor goto,...)
+ * @{
+ */
+/** @file
+ */
+#include <stdio.h>
+#include <ipc/ipc.h>
+#include <async.h>
+#include <ipc/fb.h>
+#include <bool.h>
+#include <errno.h>
+#include <console/color.h>
+#include <console/style.h>
+#include "../console/screenbuffer.h"
+#include "main.h"
+#include "serial_console.h"
+#define MAX_CONTROL 20
+static void serial_sgr(const unsigned int mode);
+static int scr_width;
+static int scr_height;
+static bool color = true;   /** True if producing color output. */
+static putc_function_t putc_function;
+/* Allow only 1 connection */
+static int client_connected = 0;
+enum sgr_color_index {
+    CI_BLACK    = 0,
+    CI_RED      = 1,
+    CI_GREEN    = 2,
+    CI_BROWN    = 3,
+    CI_BLUE     = 4,
+    CI_MAGENTA  = 5,
+    CI_CYAN     = 6,
+    CI_WHITE    = 7,
+};
+enum sgr_command {
+    SGR_RESET   = 0,
+    SGR_BOLD    = 1,
+    SGR_BLINK   = 5,
+    SGR_REVERSE = 7,
+    SGR_NORMAL_INT  = 22,
+    SGR_BLINK_OFF   = 25,
+    SGR_REVERSE_OFF = 27,
+    SGR_FGCOLOR = 30,
+    SGR_BGCOLOR = 40
+};
+static int color_map[] = {
+    [COLOR_BLACK]   = CI_BLACK,
+    [COLOR_BLUE]    = CI_RED,
+    [COLOR_GREEN]   = CI_GREEN,
+    [COLOR_CYAN]    = CI_CYAN,
+    [COLOR_RED] = CI_RED,
+    [COLOR_MAGENTA] = CI_MAGENTA,
+    [COLOR_YELLOW]  = CI_BROWN,
+    [COLOR_WHITE]   = CI_WHITE
+};
+void serial_puts(char *str)
+{
+    while (*str)
+        putc_function(*(str++));
+}
+void serial_goto(const unsigned int row, const unsigned int col)
+{
+    if ((row > scr_height) || (col > scr_width))
+        return;
+    char control[MAX_CONTROL];
+    snprintf(control, MAX_CONTROL, "\033[%u;%uf", row + 1, col + 1);
+    serial_puts(control);
+}
+void serial_clrscr(void)
+{
+    /* Initialize graphic rendition attributes. */
+    serial_sgr(SGR_RESET);
+    if (color) {
+        serial_sgr(SGR_FGCOLOR + CI_BLACK);
+        serial_sgr(SGR_BGCOLOR + CI_WHITE);
+    }
+    serial_puts("\033[2J");
+}
+void serial_scroll(int i)
+{
+    if (i > 0) {
+        serial_goto(scr_height - 1, 0);
+        while (i--)
+            serial_puts("\033D");
+    } else if (i < 0) {
+        serial_goto(0, 0);
+        while (i++)
+            serial_puts("\033M");
+    }
+}
+/** ECMA-48 Set Graphics Rendition. */
+static void serial_sgr(const unsigned int mode)
+{
+    char control[MAX_CONTROL];
+    snprintf(control, MAX_CONTROL, "\033[%um", mode);
+    serial_puts(control);
+}
+/** Set scrolling region. */
+void serial_set_scroll_region(unsigned last_row)
+{
+    char control[MAX_CONTROL];
+    snprintf(control, MAX_CONTROL, "\033[0;%ur", last_row);
+    serial_puts(control);
+}
+void serial_cursor_disable(void)
+{
+    serial_puts("\033[?25l");
+}
+void serial_cursor_enable(void)
+{
+    serial_puts("\033[?25h");
+}
+void serial_console_init(putc_function_t putc_fn, uint32_t w, uint32_t h)
+{
+    scr_width = w;
+    scr_height = h;
+    putc_function = putc_fn;
+}
+static void serial_set_style(int style)
+{
+    if (style == STYLE_EMPHASIS) {
+        if (color) {
+            serial_sgr(SGR_RESET);
+            serial_sgr(SGR_FGCOLOR + CI_RED);
+            serial_sgr(SGR_BGCOLOR + CI_WHITE);
+        }
+        serial_sgr(SGR_BOLD);
+    } else {
+        if (color) {
+            serial_sgr(SGR_RESET);
+            serial_sgr(SGR_FGCOLOR + CI_BLACK);
+            serial_sgr(SGR_BGCOLOR + CI_WHITE);
+        }
+        serial_sgr(SGR_NORMAL_INT);
+    }
+}
+static void serial_set_idx(unsigned fgcolor, unsigned bgcolor,
+    unsigned flags)
+{
+    if (color) {
+        serial_sgr(SGR_RESET);
+        serial_sgr(SGR_FGCOLOR + color_map[fgcolor]);
+        serial_sgr(SGR_BGCOLOR + color_map[bgcolor]);
+    } else {
+        if (fgcolor < bgcolor)
+            serial_sgr(SGR_RESET);
+        else
+            serial_sgr(SGR_REVERSE);
+    }
+}
+static void serial_set_rgb(uint32_t fgcolor, uint32_t bgcolor)
+{
+    if (fgcolor < bgcolor)
+        serial_sgr(SGR_REVERSE_OFF);
+    else
+        serial_sgr(SGR_REVERSE);
+}
+static void serial_set_attrs(const attrs_t *a)
+{
+    switch (a->t) {
+    case at_style: serial_set_style(a->a.s.style); break;
+    case at_rgb: serial_set_rgb(a->a.r.fg_color, a->a.r.bg_color); break;
+    case at_idx: serial_set_idx(a->a.i.fg_color,
+        a->a.i.bg_color, a->a.i.flags); break;
+    default: break;
+    }
+}
+static void draw_text_data(keyfield_t *data)
+{
+    int i, j;
+    attrs_t *a0, *a1;
+    serial_goto(0, 0);
+    a0 = &data[0].attrs;
+    serial_set_attrs(a0);
+    for (i = 0; i < scr_height; i++) {
+        for (j = 0; j < scr_width; j++) {
+            a1 = &data[i * scr_width + j].attrs;
+            if (!attrs_same(*a0, *a1))
+                serial_set_attrs(a1);
+            (*putc_function)(data[i * scr_width + j].character);
+            a0 = a1;
+        }
+    }
+}
+/**
+ * Main function of the thread serving client connections.
+ */
+void serial_client_connection(ipc_callid_t iid, ipc_call_t *icall)
+{
+    int retval;
+    ipc_callid_t callid;
+    ipc_call_t call;
+    keyfield_t *interbuf = NULL;
+    size_t intersize = 0;
+    char c;
+    int lastcol = 0;
+    int lastrow = 0;
+    int newcol;
+    int newrow;
+    int fgcolor;
+    int bgcolor;
+    int flags;
+    int style;
+    int i;
+    if (client_connected) {
+        ipc_answer_0(iid, ELIMIT);
+        return;
+    }
+    client_connected = 1;
+    ipc_answer_0(iid, EOK);
+    /* Clear the terminal, set scrolling region
+       to 0 - height rows. */
+    serial_clrscr();
+    serial_goto(0, 0);
+    serial_set_scroll_region(scr_height);
+    while (true) {
+        callid = async_get_call(&call);
+        switch (IPC_GET_METHOD(call)) {
+        case IPC_M_PHONE_HUNGUP:
+            client_connected = 0;
+            ipc_answer_0(callid, EOK);
+            return;
+        case IPC_M_SHARE_OUT:
+            /* We accept one area for data interchange */
+            intersize = IPC_GET_ARG2(call);
+            if (intersize >= scr_width * scr_height *
+                sizeof(*interbuf)) {
+                receive_comm_area(callid, &call,
+                    (void *) &interbuf);
+                continue;
+            }
+            retval = EINVAL;
+            break;
+        case FB_DRAW_TEXT_DATA:
+            if (!interbuf) {
+                retval = EINVAL;
+                break;
+            }
+            draw_text_data(interbuf);
+            retval = 0;
+            break;
+        case FB_PUTCHAR:
+            c = IPC_GET_ARG1(call);
+            newrow = IPC_GET_ARG2(call);
+            newcol = IPC_GET_ARG3(call);
+            if ((lastcol != newcol) || (lastrow != newrow))
+                serial_goto(newrow, newcol);
+            lastcol = newcol + 1;
+            lastrow = newrow;
+            (*putc_function)(c);
+            retval = 0;
+            break;
+        case FB_CURSOR_GOTO:
+            newrow = IPC_GET_ARG1(call);
+            newcol = IPC_GET_ARG2(call);
+            serial_goto(newrow, newcol);
+            lastrow = newrow;
+            lastcol = newcol;
+            retval = 0;
+            break;
+        case FB_GET_CSIZE:
+            ipc_answer_2(callid, EOK, scr_height, scr_width);
+            continue;
+        case FB_CLEAR:
+            serial_clrscr();
+            retval = 0;
+            break;
+        case FB_SET_STYLE:
+            style = IPC_GET_ARG1(call);
+            serial_set_style(style);
+            retval = 0;
+            break;
+        case FB_SET_COLOR:
+            fgcolor = IPC_GET_ARG1(call);
+            bgcolor = IPC_GET_ARG2(call);
+            flags = IPC_GET_ARG3(call);
+            serial_set_idx(fgcolor, bgcolor, flags);
+            retval = 0;
+            break;
+        case FB_SET_RGB_COLOR:
+            fgcolor = IPC_GET_ARG1(call);
+            bgcolor = IPC_GET_ARG2(call);
+            serial_set_rgb(fgcolor, bgcolor);
+            retval = 0;
+            break;
+        case FB_SCROLL:
+            i = IPC_GET_ARG1(call);
+            if ((i > scr_height) || (i < -scr_height)) {
+                retval = EINVAL;
+                break;
+            }
+            serial_scroll(i);
+            serial_goto(lastrow, lastcol);
+            retval = 0;
+            break;
+        case FB_CURSOR_VISIBILITY:
+            if(IPC_GET_ARG1(call))
+                serial_cursor_enable();
+            else
+                serial_cursor_disable();
+            retval = 0;
+            break;
+        default:
+            retval = ENOENT;
+        }
+        ipc_answer_0(callid, retval);
+    }
+}
+/**
+ * @}
+ */

 /branches/network/uspace/srv/fb/msim.c
 ,29 → 36,17
  */
 #include <async.h>
-#include <ipc/fb.h>
-#include <ipc/ipc.h>
 #include <libc.h>
-#include <errno.h>
-#include <string.h>
-#include <libc.h>
-#include <stdio.h>
-#include <ipc/fb.h>
 #include <sysinfo.h>
 #include <as.h>
-#include <align.h>
 #include <ddi.h>
+#include "serial_console.h"
 #include "msim.h"
 #define WIDTH 80
 #define HEIGHT 25
-#define MAX_CONTROL 20
-/* Allow only 1 connection */
-static int client_connected = 0;
 static char *virt_addr;
 static void msim_putc(const char c)
 ,159 → 54,17
     *virt_addr = c;
 }
-static void msim_puts(char *str)
-{
-    while (*str)
-        *virt_addr = *(str++);
-}
-static void msim_clrscr(void)
-{
-    msim_puts("\033[2J");
-}
-static void msim_goto(const unsigned int row, const unsigned int col)
-{
-    if ((row > HEIGHT) || (col > WIDTH))
-        return;
-    char control[MAX_CONTROL];
-    snprintf(control, MAX_CONTROL, "\033[%u;%uf", row + 1, col + 1);
-    msim_puts(control);
-}
-static void msim_set_style(const unsigned int mode)
-{
-    char control[MAX_CONTROL];
-    snprintf(control, MAX_CONTROL, "\033[%um", mode);
-    msim_puts(control);
-}
-static void msim_cursor_disable(void)
-{
-    msim_puts("\033[?25l");
-}
-static void msim_cursor_enable(void)
-{
-    msim_puts("\033[?25h");
-}
-static void msim_scroll(int i)
-{
-    if (i > 0) {
-        msim_goto(HEIGHT - 1, 0);
-        while (i--)
-            msim_puts("\033D");
-    } else if (i < 0) {
-        msim_goto(0, 0);
-        while (i++)
-            msim_puts("\033M");
-    }
-}
-static void msim_client_connection(ipc_callid_t iid, ipc_call_t *icall)
-{
-    int retval;
-    ipc_callid_t callid;
-    ipc_call_t call;
-    char c;
-    int lastcol = 0;
-    int lastrow = 0;
-    int newcol;
-    int newrow;
-    int fgcolor;
-    int bgcolor;
-    int i;
-    if (client_connected) {
-        ipc_answer_0(iid, ELIMIT);
-        return;
-    }
-    client_connected = 1;
-    ipc_answer_0(iid, EOK);
-    /* Clear the terminal, set scrolling region
-       to 0 - 25 lines */
-    msim_clrscr();
-    msim_goto(0, 0);
-    msim_puts("\033[0;25r");
-    while (true) {
-        callid = async_get_call(&call);
-        switch (IPC_GET_METHOD(call)) {
-        case IPC_M_PHONE_HUNGUP:
-            client_connected = 0;
-            ipc_answer_0(callid, EOK);
-            return;
-        case FB_PUTCHAR:
-            c = IPC_GET_ARG1(call);
-            newrow = IPC_GET_ARG2(call);
-            newcol = IPC_GET_ARG3(call);
-            if ((lastcol != newcol) || (lastrow != newrow))
-                msim_goto(newrow, newcol);
-            lastcol = newcol + 1;
-            lastrow = newrow;
-            msim_putc(c);
-            retval = 0;
-            break;
-        case FB_CURSOR_GOTO:
-            newrow = IPC_GET_ARG1(call);
-            newcol = IPC_GET_ARG2(call);
-            msim_goto(newrow, newcol);
-            lastrow = newrow;
-            lastcol = newcol;
-            retval = 0;
-            break;
-        case FB_GET_CSIZE:
-            ipc_answer_2(callid, EOK, HEIGHT, WIDTH);
-            continue;
-        case FB_CLEAR:
-            msim_clrscr();
-            retval = 0;
-            break;
-        case FB_SET_STYLE:
-            fgcolor = IPC_GET_ARG1(call);
-            bgcolor = IPC_GET_ARG2(call);
-            if (fgcolor < bgcolor)
-                msim_set_style(0);
-            else
-                msim_set_style(7);
-            retval = 0;
-            break;
-        case FB_SCROLL:
-            i = IPC_GET_ARG1(call);
-            if ((i > HEIGHT) || (i < -HEIGHT)) {
-                retval = EINVAL;
-                break;
-            }
-            msim_scroll(i);
-            msim_goto(lastrow, lastcol);
-            retval = 0;
-            break;
-        case FB_CURSOR_VISIBILITY:
-            if(IPC_GET_ARG1(call))
-                msim_cursor_enable();
-            else
-                msim_cursor_disable();
-            retval = 0;
-            break;
-        default:
-            retval = ENOENT;
-        }
-        ipc_answer_0(callid, retval);
-    }
-}
 int msim_init(void)
 {
     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;
-    async_set_client_connection(msim_client_connection);
+    serial_console_init(msim_putc, WIDTH, HEIGHT);
+    async_set_client_connection(serial_client_connection);
     return 0;
 }

 /branches/network/uspace/srv/fb/serial_console.h
 ,0 → 1,56
+/*
+ * 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.
+ */
+/**
+ * @defgroup serial Serial console
+ * @brief    Serial console services (putc, puts, clear screen, cursor goto,...)
+ * @{
+ */
+/** @file
+ */
+#ifndef FB_SERIAL_CONSOLE_H_
+#define FB_SERIAL_CONSOLE_H_
+#include <ipc/ipc.h>
+typedef void (*putc_function_t)(char);
+void serial_puts(char *str);
+void serial_goto(const unsigned int row, const unsigned int col);
+void serial_clrscr(void);
+void serial_scroll(int i);
+void serial_cursor_disable(void);
+void serial_cursor_enable(void);
+void serial_set_scroll_region(unsigned height);
+void serial_console_init(putc_function_t putc_fn, uint32_t w, uint32_t h);
+void serial_client_connection(ipc_callid_t iid, ipc_call_t *icall);
+#endif

 /branches/network/uspace/srv/fb/font-8x16.c
 ,7 → 28,7
 #include "font-8x16.h"
-unsigned char fb_font[FONT_GLIPHS * FONT_SCANLINES] = {
+unsigned char fb_font[FONT_GLYPHS * FONT_SCANLINES] = {
     /* 0 0x00 '^@' */
 x00, /* 00000000 */

 /branches/network/uspace/srv/fb/font-8x16.h
 ,9 → 29,11
 #ifndef FB_FONT_8X16_H_
 #define FB_FONT_8X16_H_
-#define FONT_GLIPHS 256
-#define FONT_SCANLINES  16
+#define FONT_GLYPHS      256
+#define FONT_WIDTH       8
+#define FONT_SCANLINES   16
-extern unsigned char fb_font[FONT_GLIPHS * FONT_SCANLINES];
+extern unsigned char fb_font[FONT_GLYPHS * FONT_SCANLINES];
 #endif

 /branches/network/uspace/srv/fb/main.c
 ,6 → 38,8
 #include "fb.h"
 #include "ega.h"
 #include "msim.h"
+#include "ski.h"
+#include "sgcn.h"
 #include "main.h"
 #define NAME "fb"
 ,7 → 47,7
 void receive_comm_area(ipc_callid_t callid, ipc_call_t *call, void **area)
 {
     void *dest;
     dest = as_get_mappable_page(IPC_GET_ARG2(*call));
     if (ipc_answer_1(callid, EOK, (sysarg_t) dest) == 0) {
         if (*area)
 ,12 → 62,12
     ipcarg_t phonead;
     bool initialized = false;
 #ifdef FB_ENABLED
     if (sysinfo_value("fb.kind") == 1) {
         if (fb_init() == 0)
             initialized = true;
-    }
+    }
 #endif
 #ifdef EGA_ENABLED
     if ((!initialized) && (sysinfo_value("fb.kind") == 2)) {
 ,15 → 81,28
             initialized = true;
     }
 #endif
+#ifdef SGCN_ENABLED
+    if ((!initialized) && (sysinfo_value("fb.kind") == 4)) {
+        if (sgcn_init() == 0)
+            initialized = true;
+    }
+#endif
+#ifdef SKI_ENABLED
+    if ((!initialized) && (sysinfo_value("fb") != true)) {
+        if (ski_init() == 0)
+            initialized = true;
+    }
+#endif
     if (!initialized)
         return -1;
     if (ipc_connect_to_me(PHONE_NS, SERVICE_VIDEO, 0, 0, &phonead) != 0)
         return -1;
     printf(NAME ": Accepting connections\n");
     async_manager();
     /* Never reached */
     return 0;
 }

 /branches/network/uspace/srv/fb/ski.c
 ,0 → 1,84
+/*
+ * Copyright (c) 2005 Jakub Jermar
+ * Copyright (c) 2008 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.
+ */
+/** @defgroup msimfb MSIM text console
+ * @brief   HelenOS MSIM text console.
+ * @ingroup fbs
+ * @{
+ */
+/** @file
+ */
+#include <async.h>
+#include <libc.h>
+#include <sysinfo.h>
+#include <as.h>
+#include <ddi.h>
+#include "serial_console.h"
+#include "ski.h"
+#define SKI_PUTCHAR     31
+#define WIDTH 80
+#define HEIGHT 25
+/** Display character on ski debug console
+ *
+ * Use SSC (Simulator System Call) to
+ * display character on debug console.
+ *
+ * @param ch Character to be printed.
+ */
+static void ski_putc(const char ch)
+{
+    asm volatile (
+        "mov r15 = %0\n"
+        "mov r32 = %1\n"    /* r32 is in0 */
+        "break 0x80000\n"   /* modifies r8 */
+        :
+        : "i" (SKI_PUTCHAR), "r" (ch)
+        : "r15", "in0", "r8"
+    );
+    if (ch == '\n')
+        ski_putc('\r');
+}
+int ski_init(void)
+{
+    serial_console_init(ski_putc, WIDTH, HEIGHT);
+    async_set_client_connection(serial_client_connection);
+    return 0;
+}
+/**
+ * @}
+ */

 /branches/network/uspace/srv/fb/fb.c
 ,4 → 1,5
 /*
+ * Copyright (c) 2008 Martin Decky
  * Copyright (c) 2006 Jakub Vana
  * Copyright (c) 2006 Ondrej Palkovsky
  * All rights reserved.
 ,7 → 33,7
  * @brief   HelenOS graphical framebuffer.
  * @ingroup fbs
  * @{
- */
+ */
 /** @file
  */
 ,6 → 51,8
 #include <ipc/services.h>
 #include <kernel/errno.h>
 #include <kernel/genarch/fb/visuals.h>
+#include <console/color.h>
+#include <console/style.h>
 #include <async.h>
 #include <bool.h>
 ,427 → 65,433
 #include "pointer.xbm"
 #include "pointer_mask.xbm"
-#define DEFAULT_BGCOLOR                0xf0f0f0
-#define DEFAULT_FGCOLOR                0x0
+#define DEFAULT_BGCOLOR  0xf0f0f0
+#define DEFAULT_FGCOLOR  0x000000
-/***************************************************************/
-/* Pixel specific fuctions */
+#define MAX_ANIM_LEN     8
+#define MAX_ANIMATIONS   4
+#define MAX_PIXMAPS      256  /**< Maximum number of saved pixmaps */
+#define MAX_VIEWPORTS    128  /**< Viewport is a rectangular area on the screen */
-typedef void (*conv2scr_fn_t)(void *, int);
-typedef int (*conv2rgb_fn_t)(void *);
+/** Function to render a pixel from a RGB value. */
+typedef void (*rgb_conv_t)(void *, uint32_t);
+/** Function to draw a glyph. */
+typedef void (*dg_t)(unsigned int x, unsigned int y, bool cursor,
+    uint8_t *glyphs, uint8_t glyph, uint32_t fg_color, uint32_t bg_color);
 struct {
-    uint8_t *fbaddress;
+    uint8_t *fb_addr;
     unsigned int xres;
     unsigned int yres;
     unsigned int scanline;
+    unsigned int glyphscanline;
     unsigned int pixelbytes;
-    unsigned int invert_colors;
-    conv2scr_fn_t rgb2scr;
-    conv2rgb_fn_t scr2rgb;
+    unsigned int glyphbytes;
+    rgb_conv_t rgb_conv;
 } screen;
+/** Backbuffer character cell. */
 typedef struct {
-    int initialized;
-    unsigned int x, y;
-    unsigned int width, height;
+    uint8_t glyph;
+    uint32_t fg_color;
+    uint32_t bg_color;
+} bb_cell_t;
+typedef struct {
+    bool initialized;
+    unsigned int x;
+    unsigned int y;
+    unsigned int width;
+    unsigned int height;
     /* Text support in window */
-    unsigned int rows, cols;
-    /* Style for text printing */
-    style_t style;
+    unsigned int cols;
+    unsigned int rows;
+    /*
+     * Style and glyphs for text printing
+     */
+    /** Current attributes. */
+    attr_rgb_t attr;
+    /** Pre-rendered mask for rendering glyphs. Different viewports
+     * might use different drawing functions depending on whether their
+     * scanlines are aligned on a word boundary.*/
+    uint8_t *glyphs;
+    uint8_t *bgpixel;
+    /** Glyph drawing function for this viewport. */
+    dg_t dglyph;
     /* Auto-cursor position */
-    int cursor_active, cur_col, cur_row;
-    int cursor_shown;
-    /* Double buffering */
-    uint8_t *dbdata;
-    unsigned int dboffset;
-    unsigned int paused;
+    bool cursor_active;
+    unsigned int cur_col;
+    unsigned int cur_row;
+    bool cursor_shown;
+    /* Back buffer */
+    bb_cell_t *backbuf;
+    unsigned int bbsize;
 } viewport_t;
-#define MAX_ANIM_LEN    8
-#define MAX_ANIMATIONS  4
 typedef struct {
-    int initialized;
-    int enabled;
+    bool initialized;
+    bool enabled;
     unsigned int vp;
     unsigned int pos;
     unsigned int animlen;
     unsigned int pixmaps[MAX_ANIM_LEN];
 } animation_t;
 static animation_t animations[MAX_ANIMATIONS];
-static int anims_enabled;
+static bool anims_enabled;
-/** Maximum number of saved pixmaps
- * Pixmap is a saved rectangle
- */
-#define MAX_PIXMAPS        256
 typedef struct {
     unsigned int width;
     unsigned int height;
     uint8_t *data;
 } pixmap_t;
 static pixmap_t pixmaps[MAX_PIXMAPS];
-/* Viewport is a rectangular area on the screen */
-#define MAX_VIEWPORTS 128
 static viewport_t viewports[128];
-/* Allow only 1 connection */
-static int client_connected = 0;
+static bool client_connected = false;  /**< Allow only 1 connection */
-#define RED(x, bits)    ((x >> (16 + 8 - bits)) & ((1 << bits) - 1))
-#define GREEN(x, bits)  ((x >> (8 + 8 - bits)) & ((1 << bits) - 1))
-#define BLUE(x, bits)   ((x >> (8 - bits)) & ((1 << bits) - 1))
+static uint32_t color_table[16] = {
+    [COLOR_BLACK]       = 0x000000,
+    [COLOR_BLUE]        = 0x0000f0,
+    [COLOR_GREEN]       = 0x00f000,
+    [COLOR_CYAN]        = 0x00f0f0,
+    [COLOR_RED]     = 0xf00000,
+    [COLOR_MAGENTA]     = 0xf000f0,
+    [COLOR_YELLOW]      = 0xf0f000,
+    [COLOR_WHITE]       = 0xf0f0f0,
-#define COL_WIDTH   8
-#define ROW_BYTES   (screen.scanline * FONT_SCANLINES)
+    [8 + COLOR_BLACK]   = 0x000000,
+    [8 + COLOR_BLUE]    = 0x0000ff,
+    [8 + COLOR_GREEN]   = 0x00ff00,
+    [8 + COLOR_CYAN]    = 0x00ffff,
+    [8 + COLOR_RED]     = 0xff0000,
+    [8 + COLOR_MAGENTA] = 0xff00ff,
+    [8 + COLOR_YELLOW]  = 0xffff00,
+    [8 + COLOR_WHITE]   = 0xffffff,
+};
-#define POINTPOS(x, y)  ((y) * screen.scanline + (x) * screen.pixelbytes)
+static int rgb_from_attr(attr_rgb_t *rgb, const attrs_t *a);
+static int rgb_from_style(attr_rgb_t *rgb, int style);
+static int rgb_from_idx(attr_rgb_t *rgb, ipcarg_t fg_color,
+    ipcarg_t bg_color, ipcarg_t flags);
-static inline int COLOR(int color)
-{
-    return screen.invert_colors ? ~color : color;
-}
+static int fb_set_color(viewport_t *vport, ipcarg_t fg_color,
+    ipcarg_t bg_color, ipcarg_t attr);
-/* Conversion routines between different color representations */
-static void
-rgb_byte0888(void *dst, int rgb)
-{
-    *(int *)dst = rgb;
-}
+static void draw_glyph_aligned(unsigned int x, unsigned int y, bool cursor,
+    uint8_t *glyphs, uint8_t glyph, uint32_t fg_color, uint32_t bg_color);
+static void draw_glyph_fallback(unsigned int x, unsigned int y, bool cursor,
+    uint8_t *glyphs, uint8_t glyph, uint32_t fg_color, uint32_t bg_color);
-static int
-byte0888_rgb(void *src)
-{
-    return (*(int *)src) & 0xffffff;
-}
+static void draw_vp_glyph(viewport_t *vport, bool cursor, unsigned int col,
+    unsigned int row);
-static void
-bgr_byte0888(void *dst, int rgb)
-{
-    *((uint32_t *) dst) = BLUE(rgb, 8) << 16 | GREEN(rgb, 8) << 8 |
-        RED(rgb, 8);
-}
-static int
-byte0888_bgr(void *src)
-{
-    int color = *(uint32_t *)(src);
-    return ((color & 0xff) << 16) | (((color >> 8) & 0xff) << 8) |
-        ((color >> 16) & 0xff);
-}
+#define RED(x, bits)                 ((x >> (8 + 8 + 8 - bits)) & ((1 << bits) - 1))
+#define GREEN(x, bits)               ((x >> (8 + 8 - bits)) & ((1 << bits) - 1))
+#define BLUE(x, bits)                ((x >> (8 - bits)) & ((1 << bits) - 1))
-static void
-rgb_byte888(void *dst, int rgb)
-{
-    uint8_t *scr = dst;
-#if defined(FB_INVERT_ENDIAN)
-    scr[0] = RED(rgb, 8);
-    scr[1] = GREEN(rgb, 8);
-    scr[2] = BLUE(rgb, 8);
-#else
-    scr[2] = RED(rgb, 8);
-    scr[1] = GREEN(rgb, 8);
-    scr[0] = BLUE(rgb, 8);
-#endif
-}
+#define COL2X(col)                   ((col) * FONT_WIDTH)
+#define ROW2Y(row)                   ((row) * FONT_SCANLINES)
-static int
-byte888_rgb(void *src)
-{
-    uint8_t *scr = src;
-#if defined(FB_INVERT_ENDIAN)
-    return scr[0] << 16 | scr[1] << 8 | scr[2];
-#else
-    return scr[2] << 16 | scr[1] << 8 | scr[0];
-#endif
-}
+#define X2COL(x)                     ((x) / FONT_WIDTH)
+#define Y2ROW(y)                     ((y) / FONT_SCANLINES)
-/**  16-bit depth (5:5:5) */
-static void
-rgb_byte555(void *dst, int rgb)
-{
-    /* 5-bit, 5-bits, 5-bits */
-    *((uint16_t *)(dst)) = RED(rgb, 5) << 10 | GREEN(rgb, 5) << 5 |
-        BLUE(rgb, 5);
-}
+#define FB_POS(x, y)                 ((y) * screen.scanline + (x) * screen.pixelbytes)
+#define BB_POS(vport, col, row)      ((row) * vport->cols + (col))
+#define GLYPH_POS(glyph, y, cursor)  (((glyph) + (cursor) * FONT_GLYPHS) * screen.glyphbytes + (y) * screen.glyphscanline)
-/** 16-bit depth (5:5:5) */
-static int
-byte555_rgb(void *src)
+/** ARGB 8:8:8:8 conversion
+ *
+ */
+static void rgb_0888(void *dst, uint32_t rgb)
 {
-    int color = *(uint16_t *)(src);
-    return (((color >> 10) & 0x1f) << (16 + 3)) |
-        (((color >> 5) & 0x1f) << (8 + 3)) | ((color & 0x1f) << 3);
+    *((uint32_t *) dst) = rgb & 0xffffff;
 }
-/**  16-bit depth (5:6:5) */
-static void
-rgb_byte565(void *dst, int rgb)
+/** ABGR 8:8:8:8 conversion
+ *
+ */
+static void bgr_0888(void *dst, uint32_t rgb)
 {
-    /* 5-bit, 6-bits, 5-bits */
-    *((uint16_t *)(dst)) = RED(rgb, 5) << 11 | GREEN(rgb, 6) << 5 |
-        BLUE(rgb, 5);
+    *((uint32_t *) dst)
+        = (BLUE(rgb, 8) << 16) | (GREEN(rgb, 8) << 8) | RED(rgb, 8);
 }
-/** 16-bit depth (5:6:5) */
-static int
-byte565_rgb(void *src)
+/** RGB 8:8:8 conversion
+ *
+ */
+static void rgb_888(void *dst, uint32_t rgb)
 {
-    int color = *(uint16_t *)(src);
-    return (((color >> 11) & 0x1f) << (16 + 3)) |
-        (((color >> 5) & 0x3f) << (8 + 2)) | ((color & 0x1f) << 3);
+    ((uint8_t *) dst)[0] = BLUE(rgb, 8);
+    ((uint8_t *) dst)[1] = GREEN(rgb, 8);
+    ((uint8_t *) dst)[2] = RED(rgb, 8);
 }
-/** Put pixel - 8-bit depth (3:2:3) */
-static void
-rgb_byte8(void *dst, int rgb)
+/** BGR 8:8:8 conversion
+ *
+ */
+static void bgr_888(void *dst, uint32_t rgb)
 {
-    *(uint8_t *)dst = RED(rgb, 3) << 5 | GREEN(rgb, 2) << 3 | BLUE(rgb, 3);
+    ((uint8_t *) dst)[0] = RED(rgb, 8);
+    ((uint8_t *) dst)[1] = GREEN(rgb, 8);
+    ((uint8_t *) dst)[2] = BLUE(rgb, 8);
 }
-/** Return pixel color - 8-bit depth (3:2:3) */
-static int
-byte8_rgb(void *src)
+/** RGB 5:5:5 conversion
+ *
+ */
+static void rgb_555(void *dst, uint32_t rgb)
 {
-    int color = *(uint8_t *)src;
-    return (((color >> 5) & 0x7) << (16 + 5)) |
-        (((color >> 3) & 0x3) << (8 + 6)) | ((color & 0x7) << 5);
+    *((uint16_t *) dst)
+        = (RED(rgb, 5) << 10) | (GREEN(rgb, 5) << 5) | BLUE(rgb, 5);
 }
-/** Put pixel into viewport
+/** RGB 5:6:5 conversion
  *
- * @param vport Viewport identification
- * @param x X coord relative to viewport
- * @param y Y coord relative to viewport
- * @param color RGB color
  */
-static void
-putpixel(viewport_t *vport, unsigned int x, unsigned int y, int color)
+static void rgb_565(void *dst, uint32_t rgb)
 {
-    int dx = vport->x + x;
-    int dy = vport->y + y;
-    if (! (vport->paused && vport->dbdata))
-        (*screen.rgb2scr)(&screen.fbaddress[POINTPOS(dx,dy)],
-            COLOR(color));
-    if (vport->dbdata) {
-        int dline = (y + vport->dboffset) % vport->height;
-        int doffset = screen.pixelbytes * (dline * vport->width + x);
-        (*screen.rgb2scr)(&vport->dbdata[doffset], COLOR(color));
-    }
+    *((uint16_t *) dst)
+        = (RED(rgb, 5) << 11) | (GREEN(rgb, 6) << 5) | BLUE(rgb, 5);
 }
-/** Get pixel from viewport */
-static int
-getpixel(viewport_t *vport, unsigned int x, unsigned int y)
-{
-    int dx = vport->x + x;
-    int dy = vport->y + y;
-    return COLOR((*screen.scr2rgb)(&screen.fbaddress[POINTPOS(dx, dy)]));
-}
-static inline void
-putpixel_mem(char *mem, unsigned int x, unsigned int y, int color)
+/** RGB 3:2:3
+ *
+ */
+static void rgb_323(void *dst, uint32_t rgb)
 {
-    (*screen.rgb2scr)(&mem[POINTPOS(x, y)], COLOR(color));
+    *((uint8_t *) dst)
+        = ~((RED(rgb, 3) << 5) | (GREEN(rgb, 2) << 3) | BLUE(rgb, 3));
 }
-static void
-draw_rectangle(viewport_t *vport, unsigned int sx, unsigned int sy,
-    unsigned int width, unsigned int height, int color)
+/** Draw a filled rectangle.
+ *
+ * @note Need real implementation that does not access VRAM twice.
+ */
+static void draw_filled_rect(unsigned int x0, unsigned int y0, unsigned int x1,
+    unsigned int y1, uint32_t color)
 {
     unsigned int x, y;
-    static void *tmpline;
+    unsigned int copy_bytes;
-    if (!tmpline)
-        tmpline = malloc(screen.scanline * screen.pixelbytes);
+    uint8_t *sp, *dp;
+    uint8_t cbuf[4];
-    /* Clear first line */
-    for (x = 0; x < width; x++)
-        putpixel_mem(tmpline, x, 0, color);
+    if (y0 >= y1 || x0 >= x1) return;
+    screen.rgb_conv(cbuf, color);
-    if (!vport->paused) {
-        /* Recompute to screen coords */
-        sx += vport->x;
-        sy += vport->y;
-        /* Copy the rest */
-        for (y = sy;y < sy+height; y++)
-            memcpy(&screen.fbaddress[POINTPOS(sx,y)], tmpline,
-                screen.pixelbytes * width);
+    sp = &screen.fb_addr[FB_POS(x0, y0)];
+    dp = sp;
+    /* Draw the first line. */
+    for (x = x0; x < x1; x++) {
+        memcpy(dp, cbuf, screen.pixelbytes);
+        dp += screen.pixelbytes;
     }
-    if (vport->dbdata) {
-        for (y = sy; y < sy + height; y++) {
-            int rline = (y + vport->dboffset) % vport->height;
-            int rpos = (rline * vport->width + sx) *
-                screen.pixelbytes;
-            memcpy(&vport->dbdata[rpos], tmpline,
-                screen.pixelbytes * width);
-        }
-    }
-}
+    dp = sp + screen.scanline;
+    copy_bytes = (x1 - x0) * screen.pixelbytes;
-/** Fill viewport with background color */
-static void
-clear_port(viewport_t *vport)
-{
-    draw_rectangle(vport, 0, 0, vport->width, vport->height,
-        vport->style.bg_color);
+    /* Draw the remaining lines by copying. */
+    for (y = y0 + 1; y < y1; y++) {
+        memcpy(dp, sp, copy_bytes);
+        dp += screen.scanline;
+    }
 }
-/** Scroll unbuffered viewport up/down
+/** Redraw viewport.
  *
- * @param vport Viewport to scroll
- * @param lines Positive number - scroll up, negative - scroll down
+ * @param vport Viewport to redraw
+ *
  */
-static void
-scroll_port_nodb(viewport_t *vport, int lines)
+static void vport_redraw(viewport_t *vport)
 {
-    int y;
+    unsigned int row, col;
-    if (lines > 0) {
-        for (y = vport->y; y < vport->y+vport->height - lines; y++)
-            memcpy(&screen.fbaddress[POINTPOS(vport->x,y)],
-                &screen.fbaddress[POINTPOS(vport->x,y + lines)],
-                screen.pixelbytes * vport->width);
-        draw_rectangle(vport, 0, vport->height - lines, vport->width,
-            lines, vport->style.bg_color);
-    } else if (lines < 0) {
-        lines = -lines;
-        for (y = vport->y + vport->height-1; y >= vport->y + lines; y--)
-            memcpy(&screen.fbaddress[POINTPOS(vport->x,y)],
-                &screen.fbaddress[POINTPOS(vport->x,y - lines)],
-                screen.pixelbytes * vport->width);
-        draw_rectangle(vport, 0, 0, vport->width, lines,
-            vport->style.bg_color);
+    for (row = 0; row < vport->rows; row++) {
+        for (col = 0; col < vport->cols; col++) {
+            draw_vp_glyph(vport, false, col, row);
+        }
     }
-}
-/** Refresh given viewport from double buffer */
-static void
-refresh_viewport_db(viewport_t *vport)
-{
-    unsigned int y, srcy, srcoff, dsty, dstx;
+    if (COL2X(vport->cols) < vport->width) {
+        draw_filled_rect(
+            vport->x + COL2X(vport->cols), vport->y,
+            vport->x + vport->width, vport->y + vport->height,
+            vport->attr.bg_color);
+    }
-    for (y = 0; y < vport->height; y++) {
-        srcy = (y + vport->dboffset) % vport->height;
-        srcoff = (vport->width * srcy) * screen.pixelbytes;
-        dstx = vport->x;
-        dsty = vport->y + y;
-        memcpy(&screen.fbaddress[POINTPOS(dstx,dsty)],
-            &vport->dbdata[srcoff], vport->width * screen.pixelbytes);
+    if (ROW2Y(vport->rows) < vport->height) {
+        draw_filled_rect(
+            vport->x, vport->y + ROW2Y(vport->rows),
+            vport->x + vport->width, vport->y + vport->height,
+            vport->attr.bg_color);
     }
 }
-/** Scroll viewport that has double buffering enabled */
-static void
-scroll_port_db(viewport_t *vport, int lines)
+static void backbuf_clear(bb_cell_t *backbuf, size_t len, uint32_t fg_color,
+    uint32_t bg_color)
 {
-    ++vport->paused;
-    if (lines > 0) {
-        draw_rectangle(vport, 0, 0, vport->width, lines,
-            vport->style.bg_color);
-        vport->dboffset += lines;
-        vport->dboffset %= vport->height;
-    } else if (lines < 0) {
-        lines = -lines;
-        draw_rectangle(vport, 0, vport->height-lines, vport->width,
-            lines, vport->style.bg_color);
+    unsigned i;
-        if (vport->dboffset < lines)
-            vport->dboffset += vport->height;
-        vport->dboffset -= lines;
+    for (i = 0; i < len; i++) {
+        backbuf[i].glyph = 0;
+        backbuf[i].fg_color = fg_color;
+        backbuf[i].bg_color = bg_color;
     }
-    --vport->paused;
-    refresh_viewport_db(vport);
 }
-/** Scrolls viewport given number of lines */
-static void
-scroll_port(viewport_t *vport, int lines)
+/** Clear viewport.
+ *
+ * @param vport Viewport to clear
+ *
+ */
+static void vport_clear(viewport_t *vport)
 {
-    if (vport->dbdata)
-        scroll_port_db(vport, lines);
-    else
-        scroll_port_nodb(vport, lines);
+    backbuf_clear(vport->backbuf, vport->cols * vport->rows,
+        vport->attr.fg_color, vport->attr.bg_color);
+    vport_redraw(vport);
 }
-static void
-invert_pixel(viewport_t *vport, unsigned int x, unsigned int y)
+/** Scroll viewport by the specified number of lines.
+ *
+ * @param vport Viewport to scroll
+ * @param lines Number of lines to scroll
+ *
+ */
+static void vport_scroll(viewport_t *vport, int lines)
 {
-    putpixel(vport, x, y, ~getpixel(vport, x, y));
-}
+    unsigned int row, col;
+    unsigned int x, y;
+    uint8_t glyph;
+    uint32_t fg_color;
+    uint32_t bg_color;
+    bb_cell_t *bbp, *xbp;
+    /*
+     * Redraw.
+     */
-/***************************************************************/
-/* Character-console functions */
+    y = vport->y;
+    for (row = 0; row < vport->rows; row++) {
+        x = vport->x;
+        for (col = 0; col < vport->cols; col++) {
+            if ((row + lines >= 0) && (row + lines < vport->rows)) {
+                xbp = &vport->backbuf[BB_POS(vport, col, row + lines)];
+                bbp = &vport->backbuf[BB_POS(vport, col, row)];
-/** Draw character at given position
- *
- * @param vport Viewport where the character is printed
- * @param sx Coordinates of top-left of the character
- * @param sy Coordinates of top-left of the character
- * @param style Color of the character
- * @param transparent If false, print background color
- */
-static void
-draw_glyph(viewport_t *vport,uint8_t glyph, unsigned int sx, unsigned int sy,
-    style_t style, int transparent)
-{
-    int i;
-    unsigned int y;
-    unsigned int glline;
+                glyph = xbp->glyph;
+                fg_color = xbp->fg_color;
+                bg_color = xbp->bg_color;
-    for (y = 0; y < FONT_SCANLINES; y++) {
-        glline = fb_font[glyph * FONT_SCANLINES + y];
-        for (i = 0; i < 8; i++) {
-            if (glline & (1 << (7 - i)))
-                putpixel(vport, sx + i, sy + y, style.fg_color);
-            else if (!transparent)
-                putpixel(vport, sx + i, sy + y, style.bg_color);
+                if (bbp->glyph == glyph &&
+                    bbp->fg_color == xbp->fg_color &&
+                    bbp->bg_color == xbp->bg_color) {
+                    x += FONT_WIDTH;
+                    continue;
+                }
+            } else {
+                glyph = 0;
+                fg_color = vport->attr.fg_color;
+                bg_color = vport->attr.bg_color;
+            }
+            (*vport->dglyph)(x, y, false, vport->glyphs, glyph,
+                fg_color, bg_color);
+            x += FONT_WIDTH;
         }
+        y += FONT_SCANLINES;
     }
+    /*
+     * Scroll backbuffer.
+     */
+    if (lines > 0) {
+        memmove(vport->backbuf, vport->backbuf + vport->cols * lines,
+            vport->cols * (vport->rows - lines) * sizeof(bb_cell_t));
+        backbuf_clear(&vport->backbuf[BB_POS(vport, 0, vport->rows - lines)],
+            vport->cols * lines, vport->attr.fg_color, vport->attr.bg_color);
+    } else {
+        memmove(vport->backbuf - vport->cols * lines, vport->backbuf,
+            vport->cols * (vport->rows + lines) * sizeof(bb_cell_t));
+        backbuf_clear(vport->backbuf, - vport->cols * lines,
+            vport->attr.fg_color, vport->attr.bg_color);
+    }
 }
-/** Invert character at given position */
-static void
-invert_char(viewport_t *vport,unsigned int row, unsigned int col)
+/** Render glyphs
+ *
+ * Convert glyphs from device independent font
+ * description to current visual representation.
+ *
+ * @param vport Viewport
+ *
+ */
+static void render_glyphs(viewport_t* vport)
 {
-    unsigned int x;
-    unsigned int y;
-    for (x = 0; x < COL_WIDTH; x++)
-        for (y = 0; y < FONT_SCANLINES; y++)
-            invert_pixel(vport, col * COL_WIDTH + x, row *
-                FONT_SCANLINES + y);
+    unsigned int glyph;
+    for (glyph = 0; glyph < FONT_GLYPHS; glyph++) {
+        unsigned int y;
+        for (y = 0; y < FONT_SCANLINES; y++) {
+            unsigned int x;
+            for (x = 0; x < FONT_WIDTH; x++) {
+                screen.rgb_conv(&vport->glyphs[GLYPH_POS(glyph, y, false) + x * screen.pixelbytes],
+                    (fb_font[glyph * FONT_SCANLINES + y] & (1 << (7 - x)))
+                    ? 0xffffff : 0x000000);
+                screen.rgb_conv(&vport->glyphs[GLYPH_POS(glyph, y, true) + x * screen.pixelbytes],
+                    (fb_font[glyph * FONT_SCANLINES + y] & (1 << (7 - x)))
+                    ? 0x000000 : 0xffffff);
+            }
+        }
+    }
+    screen.rgb_conv(vport->bgpixel, vport->attr.bg_color);
 }
-/***************************************************************/
-/* Stdout specific functions */
 /** Create new viewport
  *
- * @return New viewport number
+ * @param x      Origin of the viewport (x).
+ * @param y      Origin of the viewport (y).
+ * @param width  Width of the viewport.
+ * @param height Height of the viewport.
+ *
+ * @return New viewport number.
+ *
  */
-static int
-viewport_create(unsigned int x, unsigned int y,unsigned int width,
-    unsigned int height)
+static int vport_create(unsigned int x, unsigned int y,
+    unsigned int width, unsigned int height)
 {
-    int i;
+    unsigned int i;
     for (i = 0; i < MAX_VIEWPORTS; i++) {
         if (!viewports[i].initialized)
             break;
 ,75 → 498,124
     }
     if (i == MAX_VIEWPORTS)
         return ELIMIT;
+    unsigned int cols = width / FONT_WIDTH;
+    unsigned int rows = height / FONT_SCANLINES;
+    unsigned int bbsize = cols * rows * sizeof(bb_cell_t);
+    unsigned int glyphsize = 2 * FONT_GLYPHS * screen.glyphbytes;
+    unsigned int word_size = sizeof(unsigned long);
+    bb_cell_t *backbuf = (bb_cell_t *) malloc(bbsize);
+    if (!backbuf)
+        return ENOMEM;
+    uint8_t *glyphs = (uint8_t *) malloc(glyphsize);
+    if (!glyphs) {
+        free(backbuf);
+        return ENOMEM;
+    }
+    uint8_t *bgpixel = (uint8_t *) malloc(screen.pixelbytes);
+    if (!bgpixel) {
+        free(glyphs);
+        free(backbuf);
+        return ENOMEM;
+    }
+    backbuf_clear(backbuf, cols * rows, DEFAULT_FGCOLOR, DEFAULT_BGCOLOR);
+    memset(glyphs, 0, glyphsize);
+    memset(bgpixel, 0, screen.pixelbytes);
     viewports[i].x = x;
     viewports[i].y = y;
     viewports[i].width = width;
     viewports[i].height = height;
-    viewports[i].rows = height / FONT_SCANLINES;
-    viewports[i].cols = width / COL_WIDTH;
+    viewports[i].cols = cols;
+    viewports[i].rows = rows;
+    viewports[i].attr.bg_color = DEFAULT_BGCOLOR;
+    viewports[i].attr.fg_color = DEFAULT_FGCOLOR;
+    viewports[i].glyphs = glyphs;
+    viewports[i].bgpixel = bgpixel;
-    viewports[i].style.bg_color = DEFAULT_BGCOLOR;
-    viewports[i].style.fg_color = DEFAULT_FGCOLOR;
+    /*
+     * Conditions necessary  to select aligned version:
+     *
+     *   - word size is divisible by pixelbytes
+     *   - cell scanline size is divisible by word size
+     *   - cell scanlines are word-aligned
+     */
+    if ((word_size % screen.pixelbytes) == 0 &&
+        (FONT_WIDTH * screen.pixelbytes) % word_size == 0 &&
+        (x * screen.pixelbytes) % word_size == 0 &&
+        screen.scanline % word_size == 0) {
+        viewports[i].dglyph = draw_glyph_aligned;
+    } else {
+        viewports[i].dglyph = draw_glyph_fallback;
+    }
     viewports[i].cur_col = 0;
     viewports[i].cur_row = 0;
-    viewports[i].cursor_active = 0;
-    viewports[i].initialized = 1;
+    viewports[i].cursor_active = false;
+    viewports[i].cursor_shown = false;
+    viewports[i].bbsize = bbsize;
+    viewports[i].backbuf = backbuf;
+    viewports[i].initialized = true;
+    render_glyphs(&viewports[i]);
     return i;
 }
 /** Initialize framebuffer as a chardev output device
  *
- * @param addr          Address of theframebuffer
- * @param xres          Screen width in pixels
- * @param yres          Screen height in pixels
- * @param visual        Bits per pixel (8, 16, 24, 32)
- * @param scan          Bytes per one scanline
- * @param invert_colors Inverted colors.
+ * @param addr   Address of the framebuffer
+ * @param xres   Screen width in pixels
+ * @param yres   Screen height in pixels
+ * @param visual Bits per pixel (8, 16, 24, 32)
+ * @param scan   Bytes per one scanline
  *
  */
-static bool
-screen_init(void *addr, unsigned int xres, unsigned int yres,
-    unsigned int scan, unsigned int visual, bool invert_colors)
+static bool screen_init(void *addr, unsigned int xres, unsigned int yres,
+    unsigned int scan, unsigned int visual)
 {
     switch (visual) {
     case VISUAL_INDIRECT_8:
-        screen.rgb2scr = rgb_byte8;
-        screen.scr2rgb = byte8_rgb;
+        screen.rgb_conv = rgb_323;
         screen.pixelbytes = 1;
         break;
     case VISUAL_RGB_5_5_5:
-        screen.rgb2scr = rgb_byte555;
-        screen.scr2rgb = byte555_rgb;
+        screen.rgb_conv = rgb_555;
         screen.pixelbytes = 2;
         break;
     case VISUAL_RGB_5_6_5:
-        screen.rgb2scr = rgb_byte565;
-        screen.scr2rgb = byte565_rgb;
+        screen.rgb_conv = rgb_565;
         screen.pixelbytes = 2;
         break;
     case VISUAL_RGB_8_8_8:
-        screen.rgb2scr = rgb_byte888;
-        screen.scr2rgb = byte888_rgb;
+        screen.rgb_conv = rgb_888;
         screen.pixelbytes = 3;
         break;
+    case VISUAL_BGR_8_8_8:
+        screen.rgb_conv = bgr_888;
+        screen.pixelbytes = 3;
+        break;
     case VISUAL_RGB_8_8_8_0:
-        screen.rgb2scr = rgb_byte888;
-        screen.scr2rgb = byte888_rgb;
+        screen.rgb_conv = rgb_888;
         screen.pixelbytes = 4;
         break;
     case VISUAL_RGB_0_8_8_8:
-        screen.rgb2scr = rgb_byte0888;
-        screen.scr2rgb = byte0888_rgb;
+        screen.rgb_conv = rgb_0888;
         screen.pixelbytes = 4;
         break;
     case VISUAL_BGR_0_8_8_8:
-        screen.rgb2scr = bgr_byte0888;
-        screen.scr2rgb = byte0888_bgr;
+        screen.rgb_conv = bgr_0888;
         screen.pixelbytes = 4;
         break;
     default:
 ,72 → 622,239
         return false;
     }
-    screen.fbaddress = (unsigned char *) addr;
+    screen.fb_addr = (unsigned char *) addr;
     screen.xres = xres;
     screen.yres = yres;
     screen.scanline = scan;
-    screen.invert_colors = invert_colors;
+    screen.glyphscanline = FONT_WIDTH * screen.pixelbytes;
+    screen.glyphbytes = screen.glyphscanline * FONT_SCANLINES;
     /* Create first viewport */
-    viewport_create(0, 0, xres, yres);
+    vport_create(0, 0, xres, yres);
     return true;
 }
-/** Hide cursor if it is shown */
-static void
-cursor_hide(viewport_t *vport)
+/** Draw a glyph, takes advantage of alignment.
+ *
+ * This version can only be used if the following conditions are met:
+ *
+ *   - word size is divisible by pixelbytes
+ *   - cell scanline size is divisible by word size
+ *   - cell scanlines are word-aligned
+ *
+ * It makes use of the pre-rendered mask to process (possibly) several
+ * pixels at once (word size / pixelbytes pixels at a time are processed)
+ * making it very fast. Most notably this version is not applicable at 24 bits
+ * per pixel.
+ *
+ * @param x     x coordinate of top-left corner on screen.
+ * @param y     y coordinate of top-left corner on screen.
+ * @param cursor    Draw glyph with cursor
+ * @param glyphs    Pointer to font bitmap.
+ * @param glyph     Code of the glyph to draw.
+ * @param fg_color  Foreground color.
+ * @param bg_color  Backgroudn color.
+ */
+static void draw_glyph_aligned(unsigned int x, unsigned int y, bool cursor,
+    uint8_t *glyphs, uint8_t glyph, uint32_t fg_color, uint32_t bg_color)
 {
-    if (vport->cursor_active && vport->cursor_shown) {
-        invert_char(vport, vport->cur_row, vport->cur_col);
-        vport->cursor_shown = 0;
+    unsigned int i, yd;
+    unsigned long fg_buf, bg_buf;
+    unsigned long *maskp, *dp;
+    unsigned long mask;
+    unsigned int ww, d_add;
+    /*
+     * Prepare a pair of words, one filled with foreground-color
+     * pattern and the other filled with background-color pattern.
+     */
+    for (i = 0; i < sizeof(unsigned long) / screen.pixelbytes; i++) {
+        screen.rgb_conv(&((uint8_t *)&fg_buf)[i * screen.pixelbytes],
+            fg_color);
+        screen.rgb_conv(&((uint8_t *)&bg_buf)[i * screen.pixelbytes],
+            bg_color);
     }
+    /* Pointer to the current position in the mask. */
+    maskp = (unsigned long *) &glyphs[GLYPH_POS(glyph, 0, cursor)];
+    /* Pointer to the current position on the screen. */
+    dp = (unsigned long *) &screen.fb_addr[FB_POS(x, y)];
+    /* Width of the character cell in words. */
+    ww = FONT_WIDTH * screen.pixelbytes / sizeof(unsigned long);
+    /* Offset to add when moving to another screen scanline. */
+    d_add = screen.scanline - FONT_WIDTH * screen.pixelbytes;
+    for (yd = 0; yd < FONT_SCANLINES; yd++) {
+        /*
+         * Now process the cell scanline, combining foreground
+         * and background color patters using the pre-rendered mask.
+         */
+        for (i = 0; i < ww; i++) {
+            mask = *maskp++;
+            *dp++ = (fg_buf & mask) | (bg_buf & ~mask);
+        }
+        /* Move to the beginning of the next scanline of the cell. */
+        dp = (unsigned long *) ((uint8_t *) dp + d_add);
+    }
 }
-/** Show cursor if cursor showing is enabled */
-static void
-cursor_print(viewport_t *vport)
+/** Draw a glyph, fallback version.
+ *
+ * This version does not make use of the pre-rendered mask, it uses
+ * the font bitmap directly. It works always, but it is slower.
+ *
+ * @param x     x coordinate of top-left corner on screen.
+ * @param y     y coordinate of top-left corner on screen.
+ * @param cursor    Draw glyph with cursor
+ * @param glyphs    Pointer to font bitmap.
+ * @param glyph     Code of the glyph to draw.
+ * @param fg_color  Foreground color.
+ * @param bg_color  Backgroudn color.
+ */
+void draw_glyph_fallback(unsigned int x, unsigned int y, bool cursor,
+    uint8_t *glyphs, uint8_t glyph, uint32_t fg_color, uint32_t bg_color)
 {
+    unsigned int i, j, yd;
+    uint8_t fg_buf[4], bg_buf[4];
+    uint8_t *dp, *sp;
+    unsigned int d_add;
+    uint8_t b;
+    /* Pre-render 1x the foreground and background color pixels. */
+    if (cursor) {
+        screen.rgb_conv(fg_buf, bg_color);
+        screen.rgb_conv(bg_buf, fg_color);
+    } else {
+        screen.rgb_conv(fg_buf, fg_color);
+        screen.rgb_conv(bg_buf, bg_color);
+    }
+    /* Pointer to the current position on the screen. */
+    dp = (uint8_t *) &screen.fb_addr[FB_POS(x, y)];
+    /* Offset to add when moving to another screen scanline. */
+    d_add = screen.scanline - FONT_WIDTH * screen.pixelbytes;
+    for (yd = 0; yd < FONT_SCANLINES; yd++) {
+        /* Byte containing bits of the glyph scanline. */
+        b = fb_font[glyph * FONT_SCANLINES + yd];
+        for (i = 0; i < FONT_WIDTH; i++) {
+            /* Choose color based on the current bit. */
+            sp = (b & 0x80) ? fg_buf : bg_buf;
+            /* Copy the pixel. */
+            for (j = 0; j < screen.pixelbytes; j++) {
+                *dp++ = *sp++;
+            }
+            /* Move to the next bit. */
+            b = b << 1;
+        }
+        /* Move to the beginning of the next scanline of the cell. */
+        dp += d_add;
+    }
+}
+/** Draw glyph at specified position in viewport.
+ *
+ * @param vport  Viewport identification
+ * @param cursor Draw glyph with cursor
+ * @param col    Screen position relative to viewport
+ * @param row    Screen position relative to viewport
+ *
+ */
+static void draw_vp_glyph(viewport_t *vport, bool cursor, unsigned int col,
+    unsigned int row)
+{
+    unsigned int x = vport->x + COL2X(col);
+    unsigned int y = vport->y + ROW2Y(row);
+    uint8_t glyph;
+    uint32_t fg_color;
+    uint32_t bg_color;
+    glyph = vport->backbuf[BB_POS(vport, col, row)].glyph;
+    fg_color = vport->backbuf[BB_POS(vport, col, row)].fg_color;
+    bg_color = vport->backbuf[BB_POS(vport, col, row)].bg_color;
+    (*vport->dglyph)(x, y, cursor, vport->glyphs, glyph,
+        fg_color, bg_color);
+}
+/** Hide cursor if it is shown
+ *
+ */
+static void cursor_hide(viewport_t *vport)
+{
+    if ((vport->cursor_active) && (vport->cursor_shown)) {
+        draw_vp_glyph(vport, false, vport->cur_col, vport->cur_row);
+        vport->cursor_shown = false;
+    }
+}
+/** Show cursor if cursor showing is enabled
+ *
+ */
+static void cursor_show(viewport_t *vport)
+{
     /* Do not check for cursor_shown */
     if (vport->cursor_active) {
-        invert_char(vport, vport->cur_row, vport->cur_col);
-        vport->cursor_shown = 1;
+        draw_vp_glyph(vport, true, vport->cur_col, vport->cur_row);
+        vport->cursor_shown = true;
     }
 }
-/** Invert cursor, if it is enabled */
-static void
-cursor_blink(viewport_t *vport)
+/** Invert cursor, if it is enabled
+ *
+ */
+static void cursor_blink(viewport_t *vport)
 {
     if (vport->cursor_shown)
         cursor_hide(vport);
     else
-        cursor_print(vport);
+        cursor_show(vport);
 }
-/** Draw character at given position relative to viewport
- *
- * @param vport Viewport identification
- * @param c Character to print
- * @param row Screen position relative to viewport
- * @param col Screen position relative to viewport
- * @param transparent If false, print background color with character
+/** Draw character at given position relative to viewport
+ *
+ * @param vport  Viewport identification
+ * @param c      Character to draw
+ * @param col    Screen position relative to viewport
+ * @param row    Screen position relative to viewport
+ *
  */
-static void
-draw_char(viewport_t *vport, char c, unsigned int row, unsigned int col,
-    style_t style, int transparent)
+static void draw_char(viewport_t *vport, uint8_t c, unsigned int col, unsigned int row)
 {
-    /* Optimize - do not hide cursor if we are going to overwrite it */
-    if (vport->cursor_active && vport->cursor_shown &&
-        (vport->cur_col != col || vport->cur_row != row))
-        invert_char(vport, vport->cur_row, vport->cur_col);
+    bb_cell_t *bbp;
+    /* Do not hide cursor if we are going to overwrite it */
+    if ((vport->cursor_active) && (vport->cursor_shown) &&
+        ((vport->cur_col != col) || (vport->cur_row != row)))
+        cursor_hide(vport);
+    bbp = &vport->backbuf[BB_POS(vport, col, row)];
+    bbp->glyph = c;
+    bbp->fg_color = vport->attr.fg_color;
+    bbp->bg_color = vport->attr.bg_color;
+    draw_vp_glyph(vport, false, col, row);
-    draw_glyph(vport, c, col * COL_WIDTH, row * FONT_SCANLINES, style,
-        transparent);
     vport->cur_col = col;
     vport->cur_row = row;
     vport->cur_col++;
     if (vport->cur_col >= vport->cols) {
         vport->cur_col = 0;
 ,65 → 862,91
         if (vport->cur_row >= vport->rows)
             vport->cur_row--;
     }
-    cursor_print(vport);
+    cursor_show(vport);
 }
 /** Draw text data to viewport
  *
  * @param vport Viewport id
- * @param data Text data fitting exactly into viewport
+ * @param data  Text data fitting exactly into viewport
+ *
  */
-static void
-draw_text_data(viewport_t *vport, keyfield_t *data)
+static void draw_text_data(viewport_t *vport, keyfield_t *data)
 {
-    int i;
-    int col,row;
+    unsigned int i;
+    bb_cell_t *bbp;
+    attrs_t *a;
+    attr_rgb_t rgb;
+    for (i = 0; i < vport->cols * vport->rows; i++) {
+        unsigned int col = i % vport->cols;
+        unsigned int row = i / vport->cols;
+        bbp = &vport->backbuf[BB_POS(vport, col, row)];
+        uint8_t glyph = bbp->glyph;
-    clear_port(vport);
-    for (i = 0; i < vport->cols * vport->rows; i++) {
-        if (data[i].character == ' ' && style_same(data[i].style,
-            vport->style))
-            continue;
-        col = i % vport->cols;
-        row = i / vport->cols;
-        draw_glyph(vport, data[i].character, col * COL_WIDTH, row *
-            FONT_SCANLINES, data[i].style, style_same(data[i].style,
-            vport->style));
+        a = &data[i].attrs;
+        rgb_from_attr(&rgb, a);
+        bbp->glyph = data[i].character;
+        bbp->fg_color = rgb.fg_color;
+        bbp->bg_color = rgb.bg_color;
+        draw_vp_glyph(vport, false, col, row);
     }
-    cursor_print(vport);
+    cursor_show(vport);
 }
-/** Return first free pixmap */
-static int
-find_free_pixmap(void)
+static void putpixel_pixmap(void *data, unsigned int x, unsigned int y, uint32_t color)
 {
-    int i;
+    int pm = *((int *) data);
+    pixmap_t *pmap = &pixmaps[pm];
+    unsigned int pos = (y * pmap->width + x) * screen.pixelbytes;
-    for (i = 0;i < MAX_PIXMAPS;i++)
+    screen.rgb_conv(&pmap->data[pos], color);
+}
+static void putpixel(void *data, unsigned int x, unsigned int y, uint32_t color)
+{
+    viewport_t *vport = (viewport_t *) data;
+    unsigned int dx = vport->x + x;
+    unsigned int dy = vport->y + y;
+    screen.rgb_conv(&screen.fb_addr[FB_POS(dx, dy)], color);
+}
+/** Return first free pixmap
+ *
+ */
+static int find_free_pixmap(void)
+{
+    unsigned int i;
+    for (i = 0; i < MAX_PIXMAPS; i++)
         if (!pixmaps[i].data)
             return i;
     return -1;
 }
-static void
-putpixel_pixmap(int pm, unsigned int x, unsigned int y, int color)
-{
-    pixmap_t *pmap = &pixmaps[pm];
-    int pos = (y * pmap->width + x) * screen.pixelbytes;
-    (*screen.rgb2scr)(&pmap->data[pos],COLOR(color));
-}
-/** Create a new pixmap and return appropriate ID */
-static int
-shm2pixmap(unsigned char *shm, size_t size)
+/** Create a new pixmap and return appropriate ID
+ *
+ */
+static int shm2pixmap(unsigned char *shm, size_t size)
 {
     int pm;
     pixmap_t *pmap;
     pm = find_free_pixmap();
     if (pm == -1)
         return ELIMIT;
     pmap = &pixmaps[pm];
     if (ppm_get_data(shm, size, &pmap->width, &pmap->height))
 ,19 → 955,19
     pmap->data = malloc(pmap->width * pmap->height * screen.pixelbytes);
     if (!pmap->data)
         return ENOMEM;
-    ppm_draw(shm, size, 0, 0, pmap->width, pmap->height,
-        (putpixel_cb_t)putpixel_pixmap, (void *)pm);
+    ppm_draw(shm, size, 0, 0, pmap->width, pmap->height, putpixel_pixmap, (void *) &pm);
     return pm;
 }
 /** Handle shared memory communication calls
  *
  * Protocol for drawing pixmaps:
  * - FB_PREPARE_SHM(client shm identification)
  * - IPC_M_AS_AREA_SEND
- * - FB_DRAW_PPM(startx,starty)
+ * - FB_DRAW_PPM(startx, starty)
  * - FB_DROP_SHM
  *
  * Protocol for text drawing
 ,28 → 975,30
  * - FB_DRAW_TEXT_DATA
  *
  * @param callid Callid of the current call
- * @param call Current call data
- * @param vp Active viewport
- * @return 0 if the call was not handled byt this function, 1 otherwise
+ * @param call   Current call data
+ * @param vp     Active viewport
  *
- * note: this function is not threads safe, you would have
+ * @return false if the call was not handled byt this function, true otherwise
+ *
+ * Note: this function is not threads safe, you would have
  * to redefine static variables with __thread
+ *
  */
-static int
-shm_handle(ipc_callid_t callid, ipc_call_t *call, int vp)
+static bool shm_handle(ipc_callid_t callid, ipc_call_t *call, int vp)
 {
     static keyfield_t *interbuffer = NULL;
     static size_t intersize = 0;
     static unsigned char *shm = NULL;
     static ipcarg_t shm_id = 0;
     static size_t shm_size;
-    int handled = 1;
-    int retval = 0;
+    bool handled = true;
+    int retval = EOK;
     viewport_t *vport = &viewports[vp];
-    unsigned int x, y;
+    unsigned int x;
+    unsigned int y;
     switch (IPC_GET_METHOD(*call)) {
     case IPC_M_SHARE_OUT:
         /* We accept one area for data interchange */
 ,19 → 1005,20
         if (IPC_GET_ARG1(*call) == shm_id) {
             void *dest = as_get_mappable_page(IPC_GET_ARG2(*call));
             shm_size = IPC_GET_ARG2(*call);
-            if (!ipc_answer_1(callid, EOK, (sysarg_t) dest))
+            if (!ipc_answer_1(callid, EOK, (sysarg_t) dest))
                 shm = dest;
             else
                 shm_id = 0;
             if (shm[0] != 'P')
-                while (1)
-                    ;
-            return 1;
+                return false;
+            return true;
         } else {
             intersize = IPC_GET_ARG2(*call);
             receive_comm_area(callid, call, (void *) &interbuffer);
         }
-        return 1;
+        return true;
     case FB_PREPARE_SHM:
         if (shm_id)
             retval = EBUSY;
 ,7 → 1033,7
         }
         shm_id = 0;
         break;
     case FB_SHM2PIXMAP:
         if (!shm) {
             retval = EINVAL;
 ,14 → 1048,14
         }
         x = IPC_GET_ARG1(*call);
         y = IPC_GET_ARG2(*call);
-        if (x > vport->width || y > vport->height) {
+        if ((x > vport->width) || (y > vport->height)) {
             retval = EINVAL;
             break;
         }
         ppm_draw(shm, shm_size, IPC_GET_ARG1(*call),
-            IPC_GET_ARG2(*call), vport->width - x, vport->height - y,
-            (putpixel_cb_t)putpixel, vport);
+            IPC_GET_ARG2(*call), vport->width - x, vport->height - y, putpixel, (void *) vport);
         break;
     case FB_DRAW_TEXT_DATA:
         if (!interbuffer) {
 ,8 → 1062,7
             retval = EINVAL;
             break;
         }
-        if (intersize < vport->cols * vport->rows *
-            sizeof(*interbuffer)) {
+        if (intersize < vport->cols * vport->rows * sizeof(*interbuffer)) {
             retval = EINVAL;
             break;
         }
 ,7 → 1069,7
         draw_text_data(vport, interbuffer);
         break;
     default:
-        handled = 0;
+        handled = false;
     }
     if (handled)
 ,41 → 1077,39
     return handled;
 }
-static void
-copy_vp_to_pixmap(viewport_t *vport, pixmap_t *pmap)
+static void copy_vp_to_pixmap(viewport_t *vport, pixmap_t *pmap)
 {
-    int y;
-    int tmp, srcrowsize;
-    int realwidth, realheight, realrowsize;
-    int width = vport->width;
-    int height = vport->height;
+    unsigned int width = vport->width;
+    unsigned int height = vport->height;
     if (width + vport->x > screen.xres)
         width = screen.xres - vport->x;
     if (height + vport->y > screen.yres)
         height = screen.yres - vport->y;
-    realwidth = pmap->width <= width ? pmap->width : width;
-    realheight = pmap->height <= height ? pmap->height : height;
-    srcrowsize = vport->width * screen.pixelbytes;
-    realrowsize = realwidth * screen.pixelbytes;
+    unsigned int realwidth = pmap->width <= width ? pmap->width : width;
+    unsigned int realheight = pmap->height <= height ? pmap->height : height;
+    unsigned int srcrowsize = vport->width * screen.pixelbytes;
+    unsigned int realrowsize = realwidth * screen.pixelbytes;
+    unsigned int y;
     for (y = 0; y < realheight; y++) {
-        tmp = (vport->y + y) * screen.scanline +
-            vport->x * screen.pixelbytes;
-        memcpy(pmap->data + srcrowsize * y, screen.fbaddress + tmp,
-            realrowsize);
+        unsigned int tmp = (vport->y + y) * screen.scanline + vport->x * screen.pixelbytes;
+        memcpy(pmap->data + srcrowsize * y, screen.fb_addr + tmp, realrowsize);
     }
 }
-/** Save viewport to pixmap */
-static int
-save_vp_to_pixmap(viewport_t *vport)
+/** Save viewport to pixmap
+ *
+ */
+static int save_vp_to_pixmap(viewport_t *vport)
 {
     int pm;
     pixmap_t *pmap;
     pm = find_free_pixmap();
     if (pm == -1)
         return ELIMIT;
 ,58 → 1118,60
     pmap->data = malloc(screen.pixelbytes * vport->width * vport->height);
     if (!pmap->data)
         return ENOMEM;
     pmap->width = vport->width;
     pmap->height = vport->height;
     copy_vp_to_pixmap(vport, pmap);
     return pm;
 }
 /** Draw pixmap on screen
  *
  * @param vp Viewport to draw on
  * @param pm Pixmap identifier
+ *
  */
 static int draw_pixmap(int vp, int pm)
 {
     pixmap_t *pmap = &pixmaps[pm];
     viewport_t *vport = &viewports[vp];
-    int y;
-    int tmp, srcrowsize;
-    int realwidth, realheight, realrowsize;
-    int width = vport->width;
-    int height = vport->height;
+    unsigned int width = vport->width;
+    unsigned int height = vport->height;
     if (width + vport->x > screen.xres)
         width = screen.xres - vport->x;
     if (height + vport->y > screen.yres)
         height = screen.yres - vport->y;
     if (!pmap->data)
         return EINVAL;
-    realwidth = pmap->width <= width ? pmap->width : width;
-    realheight = pmap->height <= height ? pmap->height : height;
-    srcrowsize = vport->width * screen.pixelbytes;
-    realrowsize = realwidth * screen.pixelbytes;
+    unsigned int realwidth = pmap->width <= width ? pmap->width : width;
+    unsigned int realheight = pmap->height <= height ? pmap->height : height;
+    unsigned int srcrowsize = vport->width * screen.pixelbytes;
+    unsigned int realrowsize = realwidth * screen.pixelbytes;
+    unsigned int y;
     for (y = 0; y < realheight; y++) {
-        tmp = (vport->y + y) * screen.scanline +
-            vport->x * screen.pixelbytes;
-        memcpy(screen.fbaddress + tmp, pmap->data + y * srcrowsize,
-            realrowsize);
+        unsigned int tmp = (vport->y + y) * screen.scanline + vport->x * screen.pixelbytes;
+        memcpy(screen.fb_addr + tmp, pmap->data + y * srcrowsize, realrowsize);
     }
-    return 0;
+    return EOK;
 }
-/** Tick animation one step forward */
-static void
-anims_tick(void)
+/** Tick animation one step forward
+ *
+ */
+static void anims_tick(void)
 {
-    int i;
+    unsigned int i;
     static int counts = 0;
     /* Limit redrawing */
 ,37 → 1180,36
         return;
     for (i = 0; i < MAX_ANIMATIONS; i++) {
-        if (!animations[i].animlen || !animations[i].initialized ||
-            !animations[i].enabled)
+        if ((!animations[i].animlen) || (!animations[i].initialized) ||
+            (!animations[i].enabled))
             continue;
-        draw_pixmap(animations[i].vp,
-            animations[i].pixmaps[animations[i].pos]);
-        animations[i].pos = (animations[i].pos + 1) %
-            animations[i].animlen;
+        draw_pixmap(animations[i].vp, animations[i].pixmaps[animations[i].pos]);
+        animations[i].pos = (animations[i].pos + 1) % animations[i].animlen;
     }
 }
-static int pointer_x, pointer_y;
-static int pointer_shown, pointer_enabled;
+static unsigned int pointer_x;
+static unsigned int pointer_y;
+static bool pointer_shown, pointer_enabled;
 static int pointer_vport = -1;
 static int pointer_pixmap = -1;
-static void
-mouse_show(void)
+static void mouse_show(void)
 {
     int i, j;
     int visibility;
     int color;
     int bytepos;
-    if (pointer_shown || !pointer_enabled)
+    if ((pointer_shown) || (!pointer_enabled))
         return;
-    /* Save image under the cursor */
+    /* Save image under the pointer. */
     if (pointer_vport == -1) {
-        pointer_vport = viewport_create(pointer_x, pointer_y,
-            pointer_width, pointer_height);
+        pointer_vport = vport_create(pointer_x, pointer_y, pointer_width, pointer_height);
         if (pointer_vport < 0)
             return;
     } else {
 ,14 → 1216,13
         viewports[pointer_vport].x = pointer_x;
         viewports[pointer_vport].y = pointer_y;
     }
     if (pointer_pixmap == -1)
         pointer_pixmap = save_vp_to_pixmap(&viewports[pointer_vport]);
     else
-        copy_vp_to_pixmap(&viewports[pointer_vport],
-            &pixmaps[pointer_pixmap]);
-    /* Draw cursor */
+        copy_vp_to_pixmap(&viewports[pointer_vport], &pixmaps[pointer_pixmap]);
+    /* Draw mouse pointer. */
     for (i = 0; i < pointer_height; i++)
         for (j = 0; j < pointer_width; j++) {
             bytepos = i * ((pointer_width - 1) / 8 + 1) + j / 8;
 ,10 → 1240,10
     pointer_shown = 1;
 }
-static void
-mouse_hide(void)
+static void mouse_hide(void)
 {
-    /* Restore image under the cursor */
+    /* Restore image under the pointer. */
     if (pointer_shown) {
         draw_pixmap(pointer_vport, pointer_pixmap);
         pointer_shown = 0;
 ,8 → 1250,8
     }
 }
-static void
-mouse_move(unsigned int x, unsigned int y)
+static void mouse_move(unsigned int x, unsigned int y)
 {
     mouse_hide();
     pointer_x = x;
 ,14 → 1259,14
     mouse_show();
 }
-static int
-anim_handle(ipc_callid_t callid, ipc_call_t *call, int vp)
+static int anim_handle(ipc_callid_t callid, ipc_call_t *call, int vp)
 {
-    int handled = 1;
-    int retval = 0;
-    int i,nvp;
+    bool handled = true;
+    int retval = EOK;
+    int i, nvp;
     int newval;
     switch (IPC_GET_METHOD(*call)) {
     case FB_ANIM_CREATE:
         nvp = IPC_GET_ARG1(*call);
 ,14 → 1356,16
     return handled;
 }
-/** Handler for messages concerning pixmap handling */
-static int
-pixmap_handle(ipc_callid_t callid, ipc_call_t *call, int vp)
+/** Handler for messages concerning pixmap handling
+ *
+ */
+static int pixmap_handle(ipc_callid_t callid, ipc_call_t *call, int vp)
 {
-    int handled = 1;
-    int retval = 0;
-    int i,nvp;
+    bool handled = true;
+    int retval = EOK;
+    int i, nvp;
     switch (IPC_GET_METHOD(*call)) {
     case FB_VP_DRAW_PIXMAP:
         nvp = IPC_GET_ARG1(*call);
 ,7 → 1403,7
     default:
         handled = 0;
     }
     if (handled)
         ipc_answer_0(callid, retval);
     return handled;
 ,35 → 1410,99
 }
+static int rgb_from_style(attr_rgb_t *rgb, int style)
+{
+    switch (style) {
+    case STYLE_NORMAL:
+        rgb->fg_color = color_table[COLOR_BLACK];
+        rgb->bg_color = color_table[COLOR_WHITE];
+        break;
+    case STYLE_EMPHASIS:
+        rgb->fg_color = color_table[COLOR_RED];
+        rgb->bg_color = color_table[COLOR_WHITE];
+        break;
+    default:
+        return EINVAL;
+    }
+    return EOK;
+}
+static int rgb_from_idx(attr_rgb_t *rgb, ipcarg_t fg_color,
+    ipcarg_t bg_color, ipcarg_t flags)
+{
+    fg_color = (fg_color & 7) | ((flags & CATTR_BRIGHT) ? 8 : 0);
+    bg_color = (bg_color & 7) | ((flags & CATTR_BRIGHT) ? 8 : 0);
+    rgb->fg_color = color_table[fg_color];
+    rgb->bg_color = color_table[bg_color];
+    return EOK;
+}
+static int rgb_from_attr(attr_rgb_t *rgb, const attrs_t *a)
+{
+    int rc;
+    switch (a->t) {
+    case at_style:
+        rc = rgb_from_style(rgb, a->a.s.style);
+        break;
+    case at_idx:
+        rc = rgb_from_idx(rgb, a->a.i.fg_color,
+            a->a.i.bg_color, a->a.i.flags);
+        break;
+    case at_rgb:
+        *rgb = a->a.r;
+        rc = EOK;
+        break;
+    }
+    return rc;
+}
+static int fb_set_style(viewport_t *vport, ipcarg_t style)
+{
+    return rgb_from_style(&vport->attr, (int) style);
+}
+static int fb_set_color(viewport_t *vport, ipcarg_t fg_color,
+    ipcarg_t bg_color, ipcarg_t flags)
+{
+    return rgb_from_idx(&vport->attr, fg_color, bg_color, flags);
+}
 /** Function for handling connections to FB
  *
  */
-static void
-fb_client_connection(ipc_callid_t iid, ipc_call_t *icall)
+static void fb_client_connection(ipc_callid_t iid, ipc_call_t *icall)
 {
-    ipc_callid_t callid;
-    ipc_call_t call;
-    int retval;
-    int i;
-    unsigned int row,col;
-    char c;
-    int vp = 0;
-    viewport_t *vport = &viewports[0];
+    unsigned int vp = 0;
+    viewport_t *vport = &viewports[vp];
     if (client_connected) {
         ipc_answer_0(iid, ELIMIT);
         return;
     }
-    client_connected = 1;
-    ipc_answer_0(iid, EOK); /* Accept connection */
-    while (1) {
-        if (vport->cursor_active || anims_enabled)
+    /* Accept connection */
+    client_connected = true;
+    ipc_answer_0(iid, EOK);
+    while (true) {
+        ipc_callid_t callid;
+        ipc_call_t call;
+        int retval;
+        unsigned int i;
+        int scroll;
+        uint8_t glyph;
+        unsigned int row, col;
+        if ((vport->cursor_active) || (anims_enabled))
             callid = async_get_call_timeout(&call, 250000);
         else
             callid = async_get_call(&call);
         mouse_hide();
         if (!callid) {
             cursor_blink(vport);
 ,105 → 1510,89
             mouse_show();
             continue;
         }
         if (shm_handle(callid, &call, vp))
             continue;
         if (pixmap_handle(callid, &call, vp))
             continue;
         if (anim_handle(callid, &call, vp))
             continue;
-        switch (IPC_GET_METHOD(call)) {
+        switch (IPC_GET_METHOD(call)) {
         case IPC_M_PHONE_HUNGUP:
-            client_connected = 0;
-            /* cleanup other viewports */
+            client_connected = false;
+            /* Cleanup other viewports */
             for (i = 1; i < MAX_VIEWPORTS; i++)
-                vport->initialized = 0;
-            return; /* Exit thread */
+                vport->initialized = false;
+            /* Exit thread */
+            return;
         case FB_PUTCHAR:
-        case FB_TRANS_PUTCHAR:
-            c = IPC_GET_ARG1(call);
+            glyph = IPC_GET_ARG1(call);
             row = IPC_GET_ARG2(call);
             col = IPC_GET_ARG3(call);
-            if (row >= vport->rows || col >= vport->cols) {
+            if ((col >= vport->cols) || (row >= vport->rows)) {
                 retval = EINVAL;
                 break;
             }
             ipc_answer_0(callid, EOK);
-            draw_char(vport, c, row, col, vport->style,
-                IPC_GET_METHOD(call) == FB_TRANS_PUTCHAR);
-            continue; /* msg already answered */
+            draw_char(vport, glyph, col, row);
+            /* Message already answered */
+            continue;
         case FB_CLEAR:
-            clear_port(vport);
-            cursor_print(vport);
-            retval = 0;
+            vport_clear(vport);
+            cursor_show(vport);
+            retval = EOK;
             break;
-        case FB_CURSOR_GOTO:
+        case FB_CURSOR_GOTO:
             row = IPC_GET_ARG1(call);
             col = IPC_GET_ARG2(call);
-            if (row >= vport->rows || col >= vport->cols) {
+            if ((col >= vport->cols) || (row >= vport->rows)) {
                 retval = EINVAL;
                 break;
             }
-            retval = 0;
+            retval = EOK;
             cursor_hide(vport);
             vport->cur_col = col;
             vport->cur_row = row;
-            cursor_print(vport);
-            break;
+            cursor_show(vport);
+            break;
         case FB_CURSOR_VISIBILITY:
             cursor_hide(vport);
             vport->cursor_active = IPC_GET_ARG1(call);
-            cursor_print(vport);
-            retval = 0;
+            cursor_show(vport);
+            retval = EOK;
             break;
         case FB_GET_CSIZE:
             ipc_answer_2(callid, EOK, vport->rows, vport->cols);
             continue;
         case FB_SCROLL:
-            i = IPC_GET_ARG1(call);
-            if (i > vport->rows || i < (- (int)vport->rows)) {
+            scroll = IPC_GET_ARG1(call);
+            if ((scroll > (int) vport->rows) || (scroll < (-(int) vport->rows))) {
                 retval = EINVAL;
                 break;
             }
             cursor_hide(vport);
-            scroll_port(vport, i*FONT_SCANLINES);
-            cursor_print(vport);
-            retval = 0;
+            vport_scroll(vport, scroll);
+            cursor_show(vport);
+            retval = EOK;
             break;
-        case FB_VIEWPORT_DB:
-            /* Enable double buffering */
-            i = IPC_GET_ARG1(call);
-            if (i == -1)
-                i = vp;
-            if (i < 0 || i >= MAX_VIEWPORTS) {
-                retval = EINVAL;
-                break;
-            }
-            if (!viewports[i].initialized ) {
-                retval = EADDRNOTAVAIL;
-                break;
-            }
-            viewports[i].dboffset = 0;
-            if (IPC_GET_ARG2(call) == 1 && !viewports[i].dbdata)
-                viewports[i].dbdata =
-                    malloc(screen.pixelbytes *
-                    viewports[i].width * viewports[i].height);
-            else if (IPC_GET_ARG2(call) == 0 &&
-                viewports[i].dbdata) {
-                free(viewports[i].dbdata);
-                viewports[i].dbdata = NULL;
-            }
-            retval = 0;
-            break;
         case FB_VIEWPORT_SWITCH:
             i = IPC_GET_ARG1(call);
-            if (i < 0 || i >= MAX_VIEWPORTS) {
+            if (i >= MAX_VIEWPORTS) {
                 retval = EINVAL;
                 break;
             }
-            if (! viewports[i].initialized ) {
+            if (!viewports[i].initialized) {
                 retval = EADDRNOTAVAIL;
                 break;
             }
 ,11 → 1599,11
             cursor_hide(vport);
             vp = i;
             vport = &viewports[vp];
-            cursor_print(vport);
-            retval = 0;
+            cursor_show(vport);
+            retval = EOK;
             break;
         case FB_VIEWPORT_CREATE:
-            retval = viewport_create(IPC_GET_ARG1(call) >> 16,
+            retval = vport_create(IPC_GET_ARG1(call) >> 16,
                 IPC_GET_ARG1(call) & 0xffff,
                 IPC_GET_ARG2(call) >> 16,
                 IPC_GET_ARG2(call) & 0xffff);
 ,33 → 1610,42
             break;
         case FB_VIEWPORT_DELETE:
             i = IPC_GET_ARG1(call);
-            if (i < 0 || i >= MAX_VIEWPORTS) {
+            if (i >= MAX_VIEWPORTS) {
                 retval = EINVAL;
                 break;
             }
-            if (! viewports[i].initialized ) {
+            if (!viewports[i].initialized) {
                 retval = EADDRNOTAVAIL;
                 break;
             }
-            viewports[i].initialized = 0;
-            if (viewports[i].dbdata) {
-                free(viewports[i].dbdata);
-                viewports[i].dbdata = NULL;
-            }
-            retval = 0;
+            viewports[i].initialized = false;
+            if (viewports[i].glyphs)
+                free(viewports[i].glyphs);
+            if (viewports[i].bgpixel)
+                free(viewports[i].bgpixel);
+            if (viewports[i].backbuf)
+                free(viewports[i].backbuf);
+            retval = EOK;
             break;
         case FB_SET_STYLE:
-            vport->style.fg_color = IPC_GET_ARG1(call);
-            vport->style.bg_color = IPC_GET_ARG2(call);
-            retval = 0;
+            retval = fb_set_style(vport, IPC_GET_ARG1(call));
             break;
+        case FB_SET_COLOR:
+            retval = fb_set_color(vport, IPC_GET_ARG1(call),
+                IPC_GET_ARG2(call), IPC_GET_ARG3(call));
+            break;
+        case FB_SET_RGB_COLOR:
+            vport->attr.fg_color = IPC_GET_ARG1(call);
+            vport->attr.bg_color = IPC_GET_ARG2(call);
+            retval = EOK;
+            break;
         case FB_GET_RESOLUTION:
             ipc_answer_2(callid, EOK, screen.xres, screen.yres);
             continue;
         case FB_POINTER_MOVE:
-            pointer_enabled = 1;
+            pointer_enabled = true;
             mouse_move(IPC_GET_ARG1(call), IPC_GET_ARG2(call));
-            retval = 0;
+            retval = EOK;
             break;
         default:
             retval = ENOENT;
 ,41 → 1654,33
     }
 }
-/** Initialization of framebuffer */
-int
-fb_init(void)
+/** Initialization of framebuffer
+ *
+ */
+int fb_init(void)
 {
-    void *fb_ph_addr;
-    unsigned int fb_width;
-    unsigned int fb_height;
-    unsigned int fb_scanline;
-    unsigned int fb_visual;
-    bool fb_invert_colors;
-    void *fb_addr;
-    size_t asz;
     async_set_client_connection(fb_client_connection);
-    fb_ph_addr = (void *) sysinfo_value("fb.address.physical");
-    fb_width = sysinfo_value("fb.width");
-    fb_height = sysinfo_value("fb.height");
-    fb_scanline = sysinfo_value("fb.scanline");
-    fb_visual = sysinfo_value("fb.visual");
-    fb_invert_colors = sysinfo_value("fb.invert-colors");
-    asz = fb_scanline * fb_height;
-    fb_addr = as_get_mappable_page(asz);
-    physmem_map(fb_ph_addr, fb_addr, ALIGN_UP(asz, PAGE_SIZE) >>
-        PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE);
-    if (screen_init(fb_addr, fb_width, fb_height, fb_scanline, fb_visual,
-        fb_invert_colors))
+    void *fb_ph_addr = (void *) sysinfo_value("fb.address.physical");
+    unsigned int fb_offset = sysinfo_value("fb.offset");
+    unsigned int fb_width = sysinfo_value("fb.width");
+    unsigned int fb_height = sysinfo_value("fb.height");
+    unsigned int fb_scanline = sysinfo_value("fb.scanline");
+    unsigned int fb_visual = sysinfo_value("fb.visual");
+    unsigned int fbsize = fb_scanline * fb_height;
+    void *fb_addr = as_get_mappable_page(fbsize);
+    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;
     return -1;
 }
-/**
+/**
  * @}
  */

 /branches/network/uspace/srv/fb/sgcn.c
 ,0 → 1,142
+/*
+ * Copyright (c) 2006 Ondrej Palkovsky
+ * Copyright (c) 2008 Martin Decky
+ * 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.
+ */
+/** @defgroup sgcnfb SGCN
+ * @brief   userland driver of the Serengeti console output
+ * @{
+ */
+/** @file
+ */
+#include <async.h>
+#include <sysinfo.h>
+#include <as.h>
+#include <errno.h>
+#include <stdio.h>
+#include <ddi.h>
+#include "serial_console.h"
+#include "sgcn.h"
+#define WIDTH 80
+#define HEIGHT 24
+/**
+ * Virtual address mapped to SRAM.
+ */
+static uintptr_t sram_virt_addr;
+/**
+ * SGCN buffer offset within SGCN.
+ */
+static uintptr_t sram_buffer_offset;
+/**
+ * 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[24];
+    /** offset within the SGCN buffer of the output buffer start */
+    uint32_t out_begin;
+    /** offset within the SGCN buffer of the output buffer end */
+    uint32_t out_end;
+    /** offset within the SGCN buffer of the output buffer read pointer */
+    uint32_t out_rdptr;
+    /** offset within the SGCN buffer of the output buffer write pointer */
+    uint32_t out_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))
+/**
+ * Pushes the character to the SGCN serial.
+ * @param c character to be pushed
+ */
+static void sgcn_putc(char c)
+{
+    uint32_t begin = SGCN_BUFFER_HEADER->out_begin;
+    uint32_t end = SGCN_BUFFER_HEADER->out_end;
+    uint32_t size = end - begin;
+    /* we need pointers to volatile variables */
+    volatile char *buf_ptr = (volatile char *)
+        SGCN_BUFFER(char, SGCN_BUFFER_HEADER->out_wrptr);
+    volatile uint32_t *out_wrptr_ptr = &(SGCN_BUFFER_HEADER->out_wrptr);
+    volatile uint32_t *out_rdptr_ptr = &(SGCN_BUFFER_HEADER->out_rdptr);
+    uint32_t new_wrptr = (((*out_wrptr_ptr) - begin + 1) % size) + begin;
+    while (*out_rdptr_ptr == new_wrptr)
+        ;
+    *buf_ptr = c;
+    *out_wrptr_ptr = new_wrptr;
+}
+/**
+ * Initializes the SGCN serial driver.
+ */
+int sgcn_init(void)
+{
+    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");
+    async_set_client_connection(serial_client_connection);
+    return 0;
+}
+/**
+ * @}
+ */

 /branches/network/uspace/srv/fb/ski.h
 ,0 → 1,46
+/*
+ * Copyright (c) 2008 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 skifb
+ * @brief   HelenOS ski text console.
+ * @ingroup fbs
+ * @{
+ */
+/** @file
+ */
+#ifndef FB_SKI_H_
+#define FB_SKI_H_
+extern int ski_init(void);
+#endif
+/** @}
+ */

 /branches/network/uspace/srv/fb/ppm.c
 ,23 → 92,23
     int i;
     unsigned int color;
     unsigned int coef;
     /* Read magic */
-    if (data[0] != 'P' || data[1] != '6')
+    if ((data[0] != 'P') || (data[1] != '6'))
         return EINVAL;
-    data+=2;
+    data += 2;
     skip_whitespace(&data);
     read_num(&data, &width);
     skip_whitespace(&data);
-    read_num(&data,&height);
+    read_num(&data, &height);
     skip_whitespace(&data);
-    read_num(&data,&maxcolor);
+    read_num(&data, &maxcolor);
     data++;
-    if (maxcolor == 0 || maxcolor > 255 || width * height > datasz) {
+    if ((maxcolor == 0) || (maxcolor > 255) || (width * height > datasz))
         return EINVAL;
-    }
     coef = 255 / maxcolor;
     if (coef * maxcolor > 255)
         coef -= 1;
 ,6 → 125,6
         (*putpixel)(vport, sx + (i % width), sy + (i / width), color);
         data += 3;
     }
     return 0;
 }

 /branches/network/uspace/srv/fb/fb.h
 ,7 → 29,7
 /** @addtogroup fb
  * @ingroup fbs
  * @{
- */
+ */
 /** @file
  */
 ,8 → 36,10
 #ifndef FB_FB_H_
 #define FB_FB_H_
-typedef void (* putpixel_cb_t)(void *, unsigned int, unsigned int, int);
+#include <stdint.h>
+typedef void (* putpixel_cb_t)(void *, unsigned int, unsigned int, uint32_t);
 extern int fb_init(void);
 #endif

 /branches/network/uspace/srv/fb/ega.c
 ,6 → 49,9
 #include <ipc/ns.h>
 #include <ipc/services.h>
 #include <libarch/ddi.h>
+#include <console/style.h>
+#include <console/color.h>
+#include <sys/types.h>
 #include "ega.h"
 #include "../console/screenbuffer.h"
 ,13 → 64,14
 saved_screen saved_screens[MAX_SAVED_SCREENS];
-#define EGA_IO_ADDRESS 0x3d4
+#define EGA_IO_BASE ((ioport8_t *) 0x3d4)
 #define EGA_IO_SIZE 2
-#define NORMAL_COLOR       0x0f
-#define INVERTED_COLOR     0xf0
+int ega_normal_color = 0x0f;
+int ega_inverted_color = 0xf0;
-#define EGA_STYLE(fg,bg) ((fg) > (bg) ? NORMAL_COLOR : INVERTED_COLOR)
+#define NORMAL_COLOR        ega_normal_color
+#define INVERTED_COLOR      ega_inverted_color
 /* Allow only 1 connection */
 static int client_connected = 0;
 ,8 → 80,10
 static unsigned int scr_height;
 static char *scr_addr;
-static unsigned int style = NORMAL_COLOR;
+static unsigned int style;
+static unsigned attr_to_ega_style(const attrs_t *a);
 static void clrscr(void)
 {
     int i;
 ,10 → 100,10
     ega_cursor = col + scr_width * row;
-    outb(EGA_IO_ADDRESS, 0xe);
-    outb(EGA_IO_ADDRESS + 1, (ega_cursor >> 8) & 0xff);
-    outb(EGA_IO_ADDRESS, 0xf);
-    outb(EGA_IO_ADDRESS + 1, ega_cursor & 0xff);
+    pio_write_8(EGA_IO_BASE, 0xe);
+    pio_write_8(EGA_IO_BASE + 1, (ega_cursor >> 8) & 0xff);
+    pio_write_8(EGA_IO_BASE, 0xf);
+    pio_write_8(EGA_IO_BASE + 1, ega_cursor & 0xff);
 }
 static void cursor_disable(void)
 ,10 → 110,10
 {
     uint8_t stat;
-    outb(EGA_IO_ADDRESS, 0xa);
-    stat=inb(EGA_IO_ADDRESS + 1);
-    outb(EGA_IO_ADDRESS, 0xa);
-    outb(EGA_IO_ADDRESS + 1, stat | (1 << 5));
+    pio_write_8(EGA_IO_BASE, 0xa);
+    stat = pio_read_8(EGA_IO_BASE + 1);
+    pio_write_8(EGA_IO_BASE, 0xa);
+    pio_write_8(EGA_IO_BASE + 1, stat | (1 << 5));
 }
 static void cursor_enable(void)
 ,10 → 120,10
 {
     uint8_t stat;
-    outb(EGA_IO_ADDRESS, 0xa);
-    stat=inb(EGA_IO_ADDRESS + 1);
-    outb(EGA_IO_ADDRESS, 0xa);
-    outb(EGA_IO_ADDRESS + 1, stat & (~(1 << 5)));
+    pio_write_8(EGA_IO_BASE, 0xa);
+    stat = pio_read_8(EGA_IO_BASE + 1);
+    pio_write_8(EGA_IO_BASE, 0xa);
+    pio_write_8(EGA_IO_BASE + 1, stat & (~(1 << 5)));
 }
 static void scroll(int rows)
 ,13 → 130,13
 {
     int i;
     if (rows > 0) {
-        memcpy(scr_addr, ((char *) scr_addr) + rows * scr_width * 2,
+        memmove(scr_addr, ((char *) scr_addr) + rows * scr_width * 2,
             scr_width * scr_height * 2 - rows * scr_width * 2);
         for (i = 0; i < rows * scr_width; i++)
             (((short *) scr_addr) + scr_width * scr_height - rows *
                 scr_width)[i] = ((style << 8) + ' ');
     } else if (rows < 0) {
-        memcpy(((char *)scr_addr) - rows * scr_width * 2, scr_addr,
+        memmove(((char *)scr_addr) - rows * scr_width * 2, scr_addr,
             scr_width * scr_height * 2 + rows * scr_width * 2);
         for (i = 0; i < -rows * scr_width; i++)
             ((short *)scr_addr)[i] = ((style << 8 ) + ' ');
 ,8 → 157,7
     for (i = 0; i < scr_width * scr_height; i++) {
         scr_addr[i * 2] = data[i].character;
-        scr_addr[i * 2 + 1] = EGA_STYLE(data[i].style.fg_color,
-            data[i].style.bg_color);
+        scr_addr[i * 2 + 1] = attr_to_ega_style(&data[i].attrs);
     }
 }
 ,7 → 186,51
     return i;
 }
+static int style_to_ega_style(int style)
+{
+    unsigned int ega_style;
+    switch (style) {
+    case STYLE_NORMAL:
+        ega_style = INVERTED_COLOR;
+        break;
+    case STYLE_EMPHASIS:
+        ega_style = INVERTED_COLOR | 4;
+        break;
+    default:
+        return INVERTED_COLOR;
+    }
+    return ega_style;
+}
+static unsigned int color_to_ega_style(int fg_color, int bg_color, int attr)
+{
+    unsigned int style;
+    style = (fg_color & 7) | ((bg_color & 7) << 4);
+    if (attr & CATTR_BRIGHT)
+        style = style | 0x08;
+    return style;
+}
+static unsigned int rgb_to_ega_style(uint32_t fg, uint32_t bg)
+{
+    return (fg > bg) ? NORMAL_COLOR : INVERTED_COLOR;
+}
+static unsigned attr_to_ega_style(const attrs_t *a)
+{
+    switch (a->t) {
+    case at_style: return style_to_ega_style(a->a.s.style);
+    case at_rgb: return rgb_to_ega_style(a->a.r.fg_color, a->a.r.bg_color);
+    case at_idx: return color_to_ega_style(a->a.i.fg_color,
+        a->a.i.bg_color, a->a.i.flags);
+    default: return INVERTED_COLOR;
+    }
+}
 static void ega_client_connection(ipc_callid_t iid, ipc_call_t *icall)
 {
     int retval;
 ,7 → 238,8
     ipc_call_t call;
     char c;
     unsigned int row, col;
-    int bgcolor,fgcolor;
+    int bg_color, fg_color, attr;
+    uint32_t bg_rgb, fg_rgb;
     keyfield_t *interbuf = NULL;
     size_t intersize = 0;
     int i;
 ,7 → 315,7
             retval = 0;
             break;
         case FB_CURSOR_VISIBILITY:
-            if(IPC_GET_ARG1(call))
+            if (IPC_GET_ARG1(call))
                 cursor_enable();
             else
                 cursor_disable();
 ,11 → 322,22
             retval = 0;
             break;
         case FB_SET_STYLE:
-            fgcolor = IPC_GET_ARG1(call);
-            bgcolor = IPC_GET_ARG2(call);
-            style = EGA_STYLE(fgcolor, bgcolor);
+            style = style_to_ega_style(IPC_GET_ARG1(call));
             retval = 0;
             break;
+        case FB_SET_COLOR:
+            fg_color = IPC_GET_ARG1(call);
+            bg_color = IPC_GET_ARG2(call);
+            attr = IPC_GET_ARG3(call);
+            style = color_to_ega_style(fg_color, bg_color, attr);
+            retval = 0;
+            break;
+        case FB_SET_RGB_COLOR:
+            fg_rgb = IPC_GET_ARG1(call);
+            bg_rgb = IPC_GET_ARG2(call);
+            style = rgb_to_ega_style(fg_rgb, bg_rgb);
+            retval = 0;
+            break;
         case FB_VP_DRAW_PIXMAP:
             i = IPC_GET_ARG2(call);
             retval = print_screen(i);
 ,13 → 373,22
     ega_ph_addr = (void *) sysinfo_value("fb.address.physical");
     scr_width = sysinfo_value("fb.width");
     scr_height = sysinfo_value("fb.height");
-    iospace_enable(task_get_id(), (void *) EGA_IO_ADDRESS, 2);
+    if (sysinfo_value("fb.blinking")) {
+        ega_normal_color &= 0x77;
+        ega_inverted_color &= 0x77;
+    }
+    style = NORMAL_COLOR;
+    iospace_enable(task_get_id(), (void *) EGA_IO_BASE, 2);
     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);
 ,6 → 396,6
 }
-/**
+/**
  * @}
  */

 /branches/network/uspace/srv/fb/Makefile
 ,6 → 31,7
 LIBC_PREFIX = ../../lib/libc
 SOFTINT_PREFIX = ../../lib/softint
 include $(LIBC_PREFIX)/Makefile.toolchain
 CFLAGS += -I../libipc/include
 ,27 → 46,45
     main.c \
     ppm.c
-ifneq ($(ARCH), ia64)
+ifneq ($(UARCH),ia64)
     SOURCES += fb.c \
         font-8x16.c
     CFLAGS += -DFB_ENABLED
 endif
-ifeq ($(ARCH), ia32)
+ifeq ($(UARCH),ia32)
     SOURCES += ega.c
     CFLAGS += -DEGA_ENABLED
 endif
-ifeq ($(ARCH), amd64)
+ifeq ($(UARCH),ia64)
+    SOURCES += ega.c \
+        ski.c \
+        serial_console.c
+    CFLAGS += -DSKI_ENABLED
+    CFLAGS += -DEGA_ENABLED
+endif
+ifeq ($(UARCH),amd64)
     SOURCES += ega.c
     CFLAGS += -DEGA_ENABLED
 endif
-ifeq ($(ARCH), mips32)
-    SOURCES += msim.c
-    CFLAGS += -DMSIM_ENABLED -DFB_INVERT_ENDIAN
+ifeq ($(UARCH),mips32)
+    SOURCES += msim.c \
+        serial_console.c
+    CFLAGS += -DMSIM_ENABLED
 endif
-CFLAGS += -D$(ARCH)
+ifeq ($(UARCH),sparc64)
+    SOURCES += sgcn.c \
+        serial_console.c
+    CFLAGS += -DSGCN_ENABLED
+endif
+CFLAGS += -D$(UARCH)
 OBJECTS := $(addsuffix .o,$(basename $(SOURCES)))
 .PHONY: all clean depend disasm
 ,13 → 94,13
 -include Makefile.depend
 clean:
-    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend
+    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend $(OBJECTS)
 depend:
     $(CC) $(DEFS) $(CFLAGS) -M $(SOURCES) > Makefile.depend
 $(OUTPUT): $(OBJECTS) $(LIBS)
-    $(LD) -T $(LIBC_PREFIX)/arch/$(ARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
 disasm: $(OUTPUT).disasm

 /branches/network/uspace/srv/fs/tmpfs/tmpfs_dump.c
 ,17 → 38,12
 #include "tmpfs.h"
 #include "../../vfs/vfs.h"
-#include <ipc/ipc.h>
-#include <async.h>
 #include <errno.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>
 #include <as.h>
-#include <libfs.h>
-#include <ipc/services.h>
-#include <ipc/devmap.h>
-#include <sys/mman.h>
+#include <libblock.h>
 #include <byteorder.h>
 #define TMPFS_BLOCK_SIZE    1024
 ,11 → 54,12
 } __attribute__((packed));
 static bool
-tmpfs_restore_recursion(int phone, void *block, off_t *bufpos, size_t *buflen,
-    off_t *pos, tmpfs_dentry_t *parent)
+tmpfs_restore_recursion(int dev, off_t *bufpos, size_t *buflen, off_t *pos,
+    tmpfs_dentry_t *parent)
 {
     struct rdentry entry;
     libfs_ops_t *ops = &tmpfs_libfs_ops;
+    int rc;
     do {
         char *fname;
 ,8 → 66,8
         tmpfs_dentry_t *node;
         uint32_t size;
-        if (!libfs_blockread(phone, block, bufpos, buflen, pos, &entry,
-            sizeof(entry), TMPFS_BLOCK_SIZE))
+        if (block_read(dev, bufpos, buflen, pos, &entry, sizeof(entry),
+            TMPFS_BLOCK_SIZE) != EOK)
             return false;
         entry.len = uint32_t_le2host(entry.len);
 ,14 → 80,14
             if (fname == NULL)
                 return false;
-            node = (tmpfs_dentry_t *) ops->create(L_FILE);
+            node = (tmpfs_dentry_t *) ops->create(dev, L_FILE);
             if (node == NULL) {
                 free(fname);
                 return false;
             }
-            if (!libfs_blockread(phone, block, bufpos, buflen, pos,
-                fname, entry.len, TMPFS_BLOCK_SIZE)) {
+            if (block_read(dev, bufpos, buflen, pos, fname,
+                entry.len, TMPFS_BLOCK_SIZE) != EOK) {
                 ops->destroy((void *) node);
                 free(fname);
                 return false;
 ,7 → 94,8
             }
             fname[entry.len] = 0;
-            if (!ops->link((void *) parent, (void *) node, fname)) {
+            rc = ops->link((void *) parent, (void *) node, fname);
+            if (rc != EOK) {
                 ops->destroy((void *) node);
                 free(fname);
                 return false;
 ,8 → 102,8
             }
             free(fname);
-            if (!libfs_blockread(phone, block, bufpos, buflen, pos,
-                &size, sizeof(size), TMPFS_BLOCK_SIZE))
+            if (block_read(dev, bufpos, buflen, pos, &size,
+                sizeof(size), TMPFS_BLOCK_SIZE) != EOK)
                 return false;
             size = uint32_t_le2host(size);
 ,8 → 113,8
                 return false;
             node->size = size;
-            if (!libfs_blockread(phone, block, bufpos, buflen, pos,
-                node->data, size, TMPFS_BLOCK_SIZE))
+            if (block_read(dev, bufpos, buflen, pos, node->data,
+                size, TMPFS_BLOCK_SIZE) != EOK)
                 return false;
             break;
 ,21 → 123,22
             if (fname == NULL)
                 return false;
-            node = (tmpfs_dentry_t *) ops->create(L_DIRECTORY);
+            node = (tmpfs_dentry_t *) ops->create(dev, L_DIRECTORY);
             if (node == NULL) {
                 free(fname);
                 return false;
             }
-            if (!libfs_blockread(phone, block, bufpos, buflen, pos,
-                fname, entry.len, TMPFS_BLOCK_SIZE)) {
+            if (block_read(dev, bufpos, buflen, pos, fname,
+                entry.len, TMPFS_BLOCK_SIZE) != EOK) {
                 ops->destroy((void *) node);
                 free(fname);
                 return false;
             }
             fname[entry.len] = 0;
-            if (!ops->link((void *) parent, (void *) node, fname)) {
+            rc = ops->link((void *) parent, (void *) node, fname);
+            if (rc != EOK) {
                 ops->destroy((void *) node);
                 free(fname);
                 return false;
 ,8 → 145,8
             }
             free(fname);
-            if (!tmpfs_restore_recursion(phone, block, bufpos,
-                buflen, pos, node))
+            if (!tmpfs_restore_recursion(dev, bufpos, buflen, pos,
+                node))
                 return false;
             break;
 ,32 → 161,19
 bool tmpfs_restore(dev_handle_t dev)
 {
     libfs_ops_t *ops = &tmpfs_libfs_ops;
+    int rc;
-    void *block = mmap(NULL, TMPFS_BLOCK_SIZE,
-        PROTO_READ | PROTO_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
+    rc = block_init(dev, TMPFS_BLOCK_SIZE);
+    if (rc != EOK)
+        return false;
-    if (block == NULL)
-        return false;
-    int phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP,
-        DEVMAP_CONNECT_TO_DEVICE, dev);
-    if (phone < 0) {
-        munmap(block, TMPFS_BLOCK_SIZE);
-        return false;
-    }
-    if (ipc_share_out_start(phone, block, AS_AREA_READ | AS_AREA_WRITE) !=
-        EOK)
-        goto error;
     off_t bufpos = 0;
     size_t buflen = 0;
     off_t pos = 0;
     char tag[6];
-    if (!libfs_blockread(phone, block, &bufpos, &buflen, &pos, tag, 5,
-        TMPFS_BLOCK_SIZE))
+    if (block_read(dev, &bufpos, &buflen, &pos, tag, 5,
+        TMPFS_BLOCK_SIZE) != EOK)
         goto error;
     tag[5] = 0;
 ,17 → 180,15
     if (strcmp(tag, "TMPFS") != 0)
         goto error;
-    if (!tmpfs_restore_recursion(phone, block, &bufpos, &buflen, &pos,
+    if (!tmpfs_restore_recursion(dev, &bufpos, &buflen, &pos,
         ops->root_get(dev)))
         goto error;
-    ipc_hangup(phone);
-    munmap(block, TMPFS_BLOCK_SIZE);
+    block_fini(dev);
     return true;
 error:
-    ipc_hangup(phone);
-    munmap(block, TMPFS_BLOCK_SIZE);
+    block_fini(dev);
     return false;
 }

 /branches/network/uspace/srv/fs/tmpfs/tmpfs.c
 ,16 → 55,6
 vfs_info_t tmpfs_vfs_info = {
     .name = "tmpfs",
-    .ops = {
-        [IPC_METHOD_TO_VFS_OP(VFS_LOOKUP)] = VFS_OP_DEFINED,
-        [IPC_METHOD_TO_VFS_OP(VFS_READ)] = VFS_OP_DEFINED,
-        [IPC_METHOD_TO_VFS_OP(VFS_WRITE)] = VFS_OP_DEFINED,
-        [IPC_METHOD_TO_VFS_OP(VFS_TRUNCATE)] = VFS_OP_DEFINED,
-        [IPC_METHOD_TO_VFS_OP(VFS_MOUNT)] = VFS_OP_DEFINED,
-        [IPC_METHOD_TO_VFS_OP(VFS_MOUNTED)] = VFS_OP_DEFINED,
-        [IPC_METHOD_TO_VFS_OP(VFS_UNMOUNT)] = VFS_OP_NULL,
-        [IPC_METHOD_TO_VFS_OP(VFS_DESTROY)] = VFS_OP_DEFINED,
-    }
 };
 fs_reg_t tmpfs_reg;
 ,18 → 126,15
 int main(int argc, char **argv)
 {
-    int vfs_phone;
     printf(NAME ": HelenOS TMPFS file system server\n");
-    vfs_phone = ipc_connect_me_to(PHONE_NS, SERVICE_VFS, 0, 0);
-    while (vfs_phone < EOK) {
-        usleep(10000);
-        vfs_phone = ipc_connect_me_to(PHONE_NS, SERVICE_VFS, 0, 0);
+    int vfs_phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_VFS, 0, 0);
+    if (vfs_phone < EOK) {
+        printf(NAME ": Unable to connect to VFS\n");
+        return -1;
     }
-    int rc;
-    rc = fs_register(vfs_phone, &tmpfs_reg, &tmpfs_vfs_info,
+    int rc = fs_register(vfs_phone, &tmpfs_reg, &tmpfs_vfs_info,
         tmpfs_connection);
     if (rc != EOK) {
         printf(NAME ": Failed to register file system (%d)\n", rc);

 /branches/network/uspace/srv/fs/tmpfs/tmpfs_ops.c
 ,6 → 64,8
  */
 static tmpfs_dentry_t *root;
+#define TMPFS_DEV       0    /**< Dummy device handle for TMPFS */
 /*
  * Implementation of the libfs interface.
  */
 ,8 → 74,8
 static void *tmpfs_match(void *, const char *);
 static void *tmpfs_node_get(dev_handle_t, fs_index_t);
 static void tmpfs_node_put(void *);
-static void *tmpfs_create_node(int);
-static bool tmpfs_link_node(void *, void *, const char *);
+static void *tmpfs_create_node(dev_handle_t, int);
+static int tmpfs_link_node(void *, void *, const char *);
 static int tmpfs_unlink_node(void *, void *);
 static int tmpfs_destroy_node(void *);
 ,7 → 230,7
 {
     if (!hash_table_create(&dentries, DENTRIES_BUCKETS, 1, &dentries_ops))
         return false;
-    root = (tmpfs_dentry_t *) tmpfs_create_node(L_DIRECTORY);
+    root = (tmpfs_dentry_t *) tmpfs_create_node(TMPFS_DEV, L_DIRECTORY);
     if (!root) {
         hash_table_destroy(&dentries);
         return false;
 ,7 → 284,7
     /* nothing to do */
 }
-void *tmpfs_create_node(int lflag)
+void *tmpfs_create_node(dev_handle_t dev_handle, int lflag)
 {
     assert((lflag & L_FILE) ^ (lflag & L_DIRECTORY));
 ,7 → 308,7
     return (void *) node;
 }
-bool tmpfs_link_node(void *prnt, void *chld, const char *nm)
+int tmpfs_link_node(void *prnt, void *chld, const char *nm)
 {
     tmpfs_dentry_t *parentp = (tmpfs_dentry_t *) prnt;
     tmpfs_dentry_t *childp = (tmpfs_dentry_t *) chld;
 ,13 → 317,13
     tmpfs_name_t *namep = malloc(sizeof(tmpfs_name_t));
     if (!namep)
-        return false;
+        return ENOMEM;
     tmpfs_name_initialize(namep);
     size_t len = strlen(nm);
     namep->name = malloc(len + 1);
     if (!namep->name) {
         free(namep);
-        return false;
+        return ENOMEM;
     }
     strcpy(namep->name, nm);
     namep->parent = parentp;
 ,7 → 343,7
         parentp->child = childp;
     }
-    return true;
+    return EOK;
 }
 int tmpfs_unlink_node(void *prnt, void *chld)

 /branches/network/uspace/srv/fs/tmpfs/Makefile
 ,12 → 31,17
 LIBC_PREFIX = ../../../lib/libc
 LIBFS_PREFIX = ../../../lib/libfs
+LIBBLOCK_PREFIX = ../../../lib/libblock
 SOFTINT_PREFIX = ../../../lib/softint
 include $(LIBC_PREFIX)/Makefile.toolchain
-CFLAGS += -I $(LIBFS_PREFIX)
+CFLAGS += -I $(LIBFS_PREFIX) -I $(LIBBLOCK_PREFIX)
-LIBS = $(LIBC_PREFIX)/libc.a $(LIBFS_PREFIX)/libfs.a
+LIBS = \
+    $(LIBFS_PREFIX)/libfs.a \
+    $(LIBBLOCK_PREFIX)/libblock.a \
+    $(LIBC_PREFIX)/libc.a
 ## Sources
 #
 ,13 → 61,13
 -include Makefile.depend
 clean:
-    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend
+    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend $(OBJECTS)
 depend:
     $(CC) $(DEFS) $(CFLAGS) -M $(SOURCES) > Makefile.depend
 $(OUTPUT): $(OBJECTS) $(LIBS)
-    $(LD) -T $(LIBC_PREFIX)/arch/$(ARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
 disasm: $(OUTPUT).disasm

 /branches/network/uspace/srv/fs/fat/fat_idx.c
 ,7 → 214,7
 };
 /** Allocate a VFS index which is not currently in use. */
-static bool fat_idx_alloc(dev_handle_t dev_handle, fs_index_t *index)
+static bool fat_index_alloc(dev_handle_t dev_handle, fs_index_t *index)
 {
     unused_t *u;
 ,7 → 276,7
 }
 /** Free a VFS index, which is no longer in use. */
-static void fat_idx_free(dev_handle_t dev_handle, fs_index_t index)
+static void fat_index_free(dev_handle_t dev_handle, fs_index_t index)
 {
     unused_t *u;
 ,6 → 338,52
     futex_up(&unused_futex);
 }
+static fat_idx_t *fat_idx_create(dev_handle_t dev_handle)
+{
+    fat_idx_t *fidx;
+    fidx = (fat_idx_t *) malloc(sizeof(fat_idx_t));
+    if (!fidx)
+        return NULL;
+    if (!fat_index_alloc(dev_handle, &fidx->index)) {
+        free(fidx);
+        return NULL;
+    }
+    link_initialize(&fidx->uph_link);
+    link_initialize(&fidx->uih_link);
+    futex_initialize(&fidx->lock, 1);
+    fidx->dev_handle = dev_handle;
+    fidx->pfc = FAT_CLST_RES0;  /* no parent yet */
+    fidx->pdi = 0;
+    fidx->nodep = NULL;
+    return fidx;
+}
+fat_idx_t *fat_idx_get_new(dev_handle_t dev_handle)
+{
+    fat_idx_t *fidx;
+    futex_down(&used_futex);
+    fidx = fat_idx_create(dev_handle);
+    if (!fidx) {
+        futex_up(&used_futex);
+        return NULL;
+    }
+    unsigned long ikey[] = {
+        [UIH_DH_KEY] = dev_handle,
+        [UIH_INDEX_KEY] = fidx->index,
+    };
+    hash_table_insert(&ui_hash, ikey, &fidx->uih_link);
+    futex_down(&fidx->lock);
+    futex_up(&used_futex);
+    return fidx;
+}
 fat_idx_t *
 fat_idx_get_by_pos(dev_handle_t dev_handle, fat_cluster_t pfc, unsigned pdi)
 {
 ,16 → 400,11
     if (l) {
         fidx = hash_table_get_instance(l, fat_idx_t, uph_link);
     } else {
-        fidx = (fat_idx_t *) malloc(sizeof(fat_idx_t));
+        fidx = fat_idx_create(dev_handle);
         if (!fidx) {
             futex_up(&used_futex);
             return NULL;
         }
-        if (!fat_idx_alloc(dev_handle, &fidx->index)) {
-            free(fidx);
-            futex_up(&used_futex);
-            return NULL;
-        }
         unsigned long ikey[] = {
             [UIH_DH_KEY] = dev_handle,
 ,13 → 411,8
             [UIH_INDEX_KEY] = fidx->index,
         };
-        link_initialize(&fidx->uph_link);
-        link_initialize(&fidx->uih_link);
-        futex_initialize(&fidx->lock, 1);
-        fidx->dev_handle = dev_handle;
         fidx->pfc = pfc;
         fidx->pdi = pdi;
-        fidx->nodep = NULL;
         hash_table_insert(&up_hash, pkey, &fidx->uph_link);
         hash_table_insert(&ui_hash, ikey, &fidx->uih_link);
 ,6 → 423,32
     return fidx;
 }
+void fat_idx_hashin(fat_idx_t *idx)
+{
+    unsigned long pkey[] = {
+        [UPH_DH_KEY] = idx->dev_handle,
+        [UPH_PFC_KEY] = idx->pfc,
+        [UPH_PDI_KEY] = idx->pdi,
+    };
+    futex_down(&used_futex);
+    hash_table_insert(&up_hash, pkey, &idx->uph_link);
+    futex_up(&used_futex);
+}
+void fat_idx_hashout(fat_idx_t *idx)
+{
+    unsigned long pkey[] = {
+        [UPH_DH_KEY] = idx->dev_handle,
+        [UPH_PFC_KEY] = idx->pfc,
+        [UPH_PDI_KEY] = idx->pdi,
+    };
+    futex_down(&used_futex);
+    hash_table_remove(&up_hash, pkey, 3);
+    futex_up(&used_futex);
+}
 fat_idx_t *
 fat_idx_get_by_index(dev_handle_t dev_handle, fs_index_t index)
 {
 ,6 → 470,33
     return fidx;
 }
+/** Destroy the index structure.
+ *
+ * @param idx       The index structure to be destroyed.
+ */
+void fat_idx_destroy(fat_idx_t *idx)
+{
+    unsigned long ikey[] = {
+        [UIH_DH_KEY] = idx->dev_handle,
+        [UIH_INDEX_KEY] = idx->index,
+    };
+    assert(idx->pfc == FAT_CLST_RES0);
+    futex_down(&used_futex);
+    /*
+     * Since we can only free unlinked nodes, the index structure is not
+     * present in the position hash (uph). We therefore hash it out from
+     * the index hash only.
+     */
+    hash_table_remove(&ui_hash, ikey, 2);
+    futex_up(&used_futex);
+    /* Release the VFS index. */
+    fat_index_free(idx->dev_handle, idx->index);
+    /* Deallocate the structure. */
+    free(idx);
+}
 int fat_idx_init(void)
 {
     if (!hash_table_create(&up_hash, UPH_BUCKETS, 3, &uph_ops))

 /branches/network/uspace/srv/fs/fat/fat.h
 ,6 → 33,7
 #ifndef FAT_FAT_H_
 #define FAT_FAT_H_
+#include "fat_fat.h"
 #include <ipc/ipc.h>
 #include <libfs.h>
 #include <atomic.h>
 ,7 → 45,12
 #define dprintf(...)    printf(__VA_ARGS__)
 #endif
-typedef struct {
+#define min(a, b)       ((a) < (b) ? (a) : (b))
+#define BS_BLOCK        0
+#define BS_SIZE         512
+typedef struct fat_bs {
     uint8_t     ji[3];      /**< Jump instruction. */
     uint8_t     oem_name[8];
     /* BIOS Parameter Block */
 ,34 → 121,6
     };
 } __attribute__ ((packed)) fat_bs_t;
-#define FAT_ATTR_RDONLY     (1 << 0)
-#define FAT_ATTR_VOLLABEL   (1 << 3)
-#define FAT_ATTR_SUBDIR     (1 << 4)
-typedef struct {
-    uint8_t     name[8];
-    uint8_t     ext[3];
-    uint8_t     attr;
-    uint8_t     reserved;
-    uint8_t     ctime_fine;
-    uint16_t    ctime;
-    uint16_t    cdate;
-    uint16_t    adate;
-    union {
-        uint16_t    eaidx;      /* FAT12/FAT16 */
-        uint16_t    firstc_hi;  /* FAT32 */
-    };
-    uint16_t    mtime;
-    uint16_t    mdate;
-    union {
-        uint16_t    firstc;     /* FAT12/FAT16 */
-        uint16_t    firstc_lo;  /* FAT32 */
-    };
-    uint32_t    size;
-} __attribute__ ((packed)) fat_dentry_t;
-typedef uint16_t fat_cluster_t;
 typedef enum {
     FAT_INVALID,
     FAT_DIRECTORY,
 ,9 → 201,16
 extern void fat_mount(ipc_callid_t, ipc_call_t *);
 extern void fat_lookup(ipc_callid_t, ipc_call_t *);
 extern void fat_read(ipc_callid_t, ipc_call_t *);
+extern void fat_write(ipc_callid_t, ipc_call_t *);
+extern void fat_truncate(ipc_callid_t, ipc_call_t *);
+extern void fat_destroy(ipc_callid_t, ipc_call_t *);
+extern fat_idx_t *fat_idx_get_new(dev_handle_t);
 extern fat_idx_t *fat_idx_get_by_pos(dev_handle_t, fat_cluster_t, unsigned);
 extern fat_idx_t *fat_idx_get_by_index(dev_handle_t, fs_index_t);
+extern void fat_idx_destroy(fat_idx_t *);
+extern void fat_idx_hashin(fat_idx_t *);
+extern void fat_idx_hashout(fat_idx_t *);
 extern int fat_idx_init(void);
 extern void fat_idx_fini(void);

 /branches/network/uspace/srv/fs/fat/fat_dentry.c
 ,0 → 1,204
+/*
+ * Copyright (c) 2008 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 fs
+ * @{
+ */
+/**
+ * @file    fat_dentry.c
+ * @brief   Functions that work with FAT directory entries.
+ */
+#include "fat_dentry.h"
+#include <ctype.h>
+#include <string.h>
+static bool is_d_char(const char ch)
+{
+    if (isalnum(ch) || ch == '_')
+        return true;
+    else
+        return false;
+}
+/** Compare path component with the name read from the dentry.
+ *
+ * This function compares the path component with the name read from the dentry.
+ * The comparison is case insensitive and tolerates a mismatch on the trailing
+ * dot character at the end of the name (i.e. when there is a dot, but no
+ * extension).
+ *
+ * @param name      Node name read from the dentry.
+ * @param component Path component.
+ *
+ * @return      Zero on match, non-zero otherwise.
+ */
+int fat_dentry_namecmp(char *name, const char *component)
+{
+    int rc;
+    if (!(rc = stricmp(name, component)))
+        return rc;
+    if (!strchr(name, '.')) {
+        /*
+         * There is no '.' in the name, so we know that there is enough
+         * space for appending an extra '.' to name.
+         */
+        name[strlen(name)] = '.';
+        name[strlen(name) + 1] = '\0';
+        rc = stricmp(name, component);
+    }
+    return rc;
+}
+bool fat_dentry_name_verify(const char *name)
+{
+    unsigned i, dot;
+    bool dot_found = false;
+    for (i = 0; name[i]; i++) {
+        if (name[i] == '.') {
+            if (dot_found) {
+                return false;
+            } else {
+                dot_found = true;
+                dot = i;
+            }
+        } else {
+            if (!is_d_char(name[i]))
+                return false;
+        }
+    }
+    if (dot_found) {
+        if (dot > FAT_NAME_LEN)
+            return false;
+        if (i - dot > FAT_EXT_LEN + 1)
+            return false;
+    } else {
+        if (i > FAT_NAME_LEN)
+            return false;
+    }
+    return true;
+}
+void fat_dentry_name_get(const fat_dentry_t *d, char *buf)
+{
+    int i;
+    for (i = 0; i < FAT_NAME_LEN; i++) {
+        if (d->name[i] == FAT_PAD)
+            break;
+        if (d->name[i] == FAT_DENTRY_E5_ESC)
+            *buf++ = 0xe5;
+        else
+            *buf++ = d->name[i];
+    }
+    if (d->ext[0] != FAT_PAD)
+        *buf++ = '.';
+    for (i = 0; i < FAT_EXT_LEN; i++) {
+        if (d->ext[i] == FAT_PAD) {
+            *buf = '\0';
+            return;
+        }
+        if (d->ext[i] == FAT_DENTRY_E5_ESC)
+            *buf++ = 0xe5;
+        else
+            *buf++ = d->ext[i];
+    }
+    *buf = '\0';
+}
+void fat_dentry_name_set(fat_dentry_t *d, const char *name)
+{
+    int i;
+    const char fake_ext[] = "   ";
+    for (i = 0; i < FAT_NAME_LEN; i++) {
+        switch ((uint8_t) *name) {
+        case 0xe5:
+            d->name[i] = FAT_DENTRY_E5_ESC;
+            name++;
+            break;
+        case '\0':
+        case '.':
+            d->name[i] = FAT_PAD;
+            break;
+        default:
+            d->name[i] = toupper(*name++);
+            break;
+        }
+    }
+    if (*name++ != '.')
+        name = fake_ext;
+    for (i = 0; i < FAT_EXT_LEN; i++) {
+        switch ((uint8_t) *name) {
+        case 0xe5:
+            d->ext[i] = FAT_DENTRY_E5_ESC;
+            name++;
+            break;
+        case '\0':
+            d->ext[i] = FAT_PAD;
+            break;
+        default:
+            d->ext[i] = toupper(*name++);
+            break;
+        }
+    }
+}
+fat_dentry_clsf_t fat_classify_dentry(const fat_dentry_t *d)
+{
+    if (d->attr & FAT_ATTR_VOLLABEL) {
+        /* volume label entry */
+        return FAT_DENTRY_SKIP;
+    }
+    if (d->name[0] == FAT_DENTRY_ERASED) {
+        /* not-currently-used entry */
+        return FAT_DENTRY_FREE;
+    }
+    if (d->name[0] == FAT_DENTRY_UNUSED) {
+        /* never used entry */
+        return FAT_DENTRY_LAST;
+    }
+    if (d->name[0] == FAT_DENTRY_DOT) {
+        /*
+         * Most likely '.' or '..'.
+         * It cannot occur in a regular file name.
+         */
+        return FAT_DENTRY_SKIP;
+    }
+    return FAT_DENTRY_VALID;
+}
+/**
+ * @}
+ */

 /branches/network/uspace/srv/fs/fat/fat_dentry.h
 ,0 → 1,96
+/*
+ * Copyright (c) 2008 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 fs
+ * @{
+ */
+#ifndef FAT_FAT_DENTRY_H_
+#define FAT_FAT_DENTRY_H_
+#include <stdint.h>
+#include <bool.h>
+#define FAT_NAME_LEN        8
+#define FAT_EXT_LEN     3
+#define FAT_NAME_DOT        ".       "
+#define FAT_NAME_DOT_DOT    "..      "
+#define FAT_EXT_PAD     "   "
+#define FAT_ATTR_RDONLY     (1 << 0)
+#define FAT_ATTR_VOLLABEL   (1 << 3)
+#define FAT_ATTR_SUBDIR     (1 << 4)
+#define FAT_PAD         ' '
+#define FAT_DENTRY_UNUSED   0x00
+#define FAT_DENTRY_E5_ESC   0x05
+#define FAT_DENTRY_DOT      0x2e
+#define FAT_DENTRY_ERASED   0xe5
+typedef enum {
+    FAT_DENTRY_SKIP,
+    FAT_DENTRY_LAST,
+    FAT_DENTRY_FREE,
+    FAT_DENTRY_VALID
+} fat_dentry_clsf_t;
+typedef struct {
+    uint8_t     name[8];
+    uint8_t     ext[3];
+    uint8_t     attr;
+    uint8_t     reserved;
+    uint8_t     ctime_fine;
+    uint16_t    ctime;
+    uint16_t    cdate;
+    uint16_t    adate;
+    union {
+        uint16_t    eaidx;      /* FAT12/FAT16 */
+        uint16_t    firstc_hi;  /* FAT32 */
+    } __attribute__ ((packed));
+    uint16_t    mtime;
+    uint16_t    mdate;
+    union {
+        uint16_t    firstc;     /* FAT12/FAT16 */
+        uint16_t    firstc_lo;  /* FAT32 */
+    } __attribute__ ((packed));
+    uint32_t    size;
+} __attribute__ ((packed)) fat_dentry_t;
+extern int fat_dentry_namecmp(char *, const char *);
+extern bool fat_dentry_name_verify(const char *);
+extern void fat_dentry_name_get(const fat_dentry_t *, char *);
+extern void fat_dentry_name_set(fat_dentry_t *, const char *);
+extern fat_dentry_clsf_t fat_classify_dentry(const fat_dentry_t *);
+#endif
+/**
+ * @}
+ */

 /branches/network/uspace/srv/fs/fat/fat_fat.c
 ,0 → 1,454
+/*
+ * Copyright (c) 2008 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 fs
+ * @{
+ */
+/**
+ * @file    fat_fat.c
+ * @brief   Functions that manipulate the File Allocation Tables.
+ */
+#include "fat_fat.h"
+#include "fat_dentry.h"
+#include "fat.h"
+#include "../../vfs/vfs.h"
+#include <libfs.h>
+#include <libblock.h>
+#include <errno.h>
+#include <byteorder.h>
+#include <align.h>
+#include <assert.h>
+#include <futex.h>
+/**
+ * The fat_alloc_lock futex protects all copies of the File Allocation Table
+ * during allocation of clusters. The lock does not have to be held durring
+ * deallocation of clusters.
+ */
+static futex_t fat_alloc_lock = FUTEX_INITIALIZER;
+/** Walk the cluster chain.
+ *
+ * @param bs        Buffer holding the boot sector for the file.
+ * @param dev_handle    Device handle of the device with the file.
+ * @param firstc    First cluster to start the walk with.
+ * @param lastc     If non-NULL, output argument hodling the last cluster number visited.
+ * @param max_clusters  Maximum number of clusters to visit.
+ *
+ * @return      Number of clusters seen during the walk.
+ */
+uint16_t
+fat_cluster_walk(fat_bs_t *bs, dev_handle_t dev_handle, fat_cluster_t firstc,
+    fat_cluster_t *lastc, uint16_t max_clusters)
+{
+    block_t *b;
+    unsigned bps;
+    unsigned rscnt;     /* block address of the first FAT */
+    uint16_t clusters = 0;
+    fat_cluster_t clst = firstc;
+    bps = uint16_t_le2host(bs->bps);
+    rscnt = uint16_t_le2host(bs->rscnt);
+    if (firstc == FAT_CLST_RES0) {
+        /* No space allocated to the file. */
+        if (lastc)
+            *lastc = firstc;
+        return 0;
+    }
+    while (clst < FAT_CLST_LAST1 && clusters < max_clusters) {
+        bn_t fsec;  /* sector offset relative to FAT1 */
+        unsigned fidx;  /* FAT1 entry index */
+        assert(clst >= FAT_CLST_FIRST);
+        if (lastc)
+            *lastc = clst;  /* remember the last cluster number */
+        fsec = (clst * sizeof(fat_cluster_t)) / bps;
+        fidx = clst % (bps / sizeof(fat_cluster_t));
+        /* read FAT1 */
+        b = block_get(dev_handle, rscnt + fsec, BLOCK_FLAGS_NONE);
+        clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]);
+        assert(clst != FAT_CLST_BAD);
+        block_put(b);
+        clusters++;
+    }
+    if (lastc && clst < FAT_CLST_LAST1)
+        *lastc = clst;
+    return clusters;
+}
+/** Read block from file located on a FAT file system.
+ *
+ * @param bs        Buffer holding the boot sector of the file system.
+ * @param dev_handle    Device handle of the file system.
+ * @param firstc    First cluster used by the file. Can be zero if the file
+ *          is empty.
+ * @param bn        Block number.
+ * @param flags     Flags passed to libblock.
+ *
+ * @return      Block structure holding the requested block.
+ */
+block_t *
+_fat_block_get(fat_bs_t *bs, dev_handle_t dev_handle, fat_cluster_t firstc,
+    bn_t bn, int flags)
+{
+    block_t *b;
+    unsigned bps;
+    unsigned rscnt;     /* block address of the first FAT */
+    unsigned rde;
+    unsigned rds;       /* root directory size */
+    unsigned sf;
+    unsigned ssa;       /* size of the system area */
+    unsigned clusters, max_clusters;
+    fat_cluster_t lastc;
+    bps = uint16_t_le2host(bs->bps);
+    rscnt = uint16_t_le2host(bs->rscnt);
+    rde = uint16_t_le2host(bs->root_ent_max);
+    sf = uint16_t_le2host(bs->sec_per_fat);
+    rds = (sizeof(fat_dentry_t) * rde) / bps;
+    rds += ((sizeof(fat_dentry_t) * rde) % bps != 0);
+    ssa = rscnt + bs->fatcnt * sf + rds;
+    if (firstc == FAT_CLST_ROOT) {
+        /* root directory special case */
+        assert(bn < rds);
+        b = block_get(dev_handle, rscnt + bs->fatcnt * sf + bn, flags);
+        return b;
+    }
+    max_clusters = bn / bs->spc;
+    clusters = fat_cluster_walk(bs, dev_handle, firstc, &lastc,
+        max_clusters);
+    assert(clusters == max_clusters);
+    b = block_get(dev_handle, ssa + (lastc - FAT_CLST_FIRST) * bs->spc +
+        bn % bs->spc, flags);
+    return b;
+}
+/** Fill the gap between EOF and a new file position.
+ *
+ * @param bs        Buffer holding the boot sector for nodep.
+ * @param nodep     FAT node with the gap.
+ * @param mcl       First cluster in an independent cluster chain that will
+ *          be later appended to the end of the node's own cluster
+ *          chain. If pos is still in the last allocated cluster,
+ *          this argument is ignored.
+ * @param pos       Position in the last node block.
+ */
+void fat_fill_gap(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl, off_t pos)
+{
+    uint16_t bps;
+    unsigned spc;
+    block_t *b;
+    off_t o, boundary;
+    bps = uint16_t_le2host(bs->bps);
+    spc = bs->spc;
+    boundary = ROUND_UP(nodep->size, bps * spc);
+    /* zero out already allocated space */
+    for (o = nodep->size; o < pos && o < boundary;
+        o = ALIGN_DOWN(o + bps, bps)) {
+            int flags = (o % bps == 0) ?
+            BLOCK_FLAGS_NOREAD : BLOCK_FLAGS_NONE;
+        b = fat_block_get(bs, nodep, o / bps, flags);
+        memset(b->data + o % bps, 0, bps - o % bps);
+        b->dirty = true;        /* need to sync node */
+        block_put(b);
+    }
+    if (o >= pos)
+        return;
+    /* zero out the initial part of the new cluster chain */
+    for (o = boundary; o < pos; o += bps) {
+        b = _fat_block_get(bs, nodep->idx->dev_handle, mcl,
+            (o - boundary) / bps, BLOCK_FLAGS_NOREAD);
+        memset(b->data, 0, min(bps, pos - o));
+        b->dirty = true;        /* need to sync node */
+        block_put(b);
+    }
+}
+/** Get cluster from the first FAT.
+ *
+ * @param bs        Buffer holding the boot sector for the file system.
+ * @param dev_handle    Device handle for the file system.
+ * @param clst      Cluster which to get.
+ *
+ * @return      Value found in the cluster.
+ */
+fat_cluster_t
+fat_get_cluster(fat_bs_t *bs, dev_handle_t dev_handle, fat_cluster_t clst)
+{
+    block_t *b;
+    uint16_t bps;
+    uint16_t rscnt;
+    fat_cluster_t *cp, value;
+    bps = uint16_t_le2host(bs->bps);
+    rscnt = uint16_t_le2host(bs->rscnt);
+    b = block_get(dev_handle, rscnt + (clst * sizeof(fat_cluster_t)) / bps,
+        BLOCK_FLAGS_NONE);
+    cp = (fat_cluster_t *)b->data + clst % (bps / sizeof(fat_cluster_t));
+    value = uint16_t_le2host(*cp);
+    block_put(b);
+    return value;
+}
+/** Set cluster in one instance of FAT.
+ *
+ * @param bs        Buffer holding the boot sector for the file system.
+ * @param dev_handle    Device handle for the file system.
+ * @param fatno     Number of the FAT instance where to make the change.
+ * @param clst      Cluster which is to be set.
+ * @param value     Value to set the cluster with.
+ */
+void
+fat_set_cluster(fat_bs_t *bs, dev_handle_t dev_handle, unsigned fatno,
+    fat_cluster_t clst, fat_cluster_t value)
+{
+    block_t *b;
+    uint16_t bps;
+    uint16_t rscnt;
+    uint16_t sf;
+    fat_cluster_t *cp;
+    bps = uint16_t_le2host(bs->bps);
+    rscnt = uint16_t_le2host(bs->rscnt);
+    sf = uint16_t_le2host(bs->sec_per_fat);
+    assert(fatno < bs->fatcnt);
+    b = block_get(dev_handle, rscnt + sf * fatno +
+        (clst * sizeof(fat_cluster_t)) / bps, BLOCK_FLAGS_NONE);
+    cp = (fat_cluster_t *)b->data + clst % (bps / sizeof(fat_cluster_t));
+    *cp = host2uint16_t_le(value);
+    b->dirty = true;        /* need to sync block */
+    block_put(b);
+}
+/** Replay the allocatoin of clusters in all shadow instances of FAT.
+ *
+ * @param bs        Buffer holding the boot sector of the file system.
+ * @param dev_handle    Device handle of the file system.
+ * @param lifo      Chain of allocated clusters.
+ * @param nclsts    Number of clusters in the lifo chain.
+ */
+void fat_alloc_shadow_clusters(fat_bs_t *bs, dev_handle_t dev_handle,
+    fat_cluster_t *lifo, unsigned nclsts)
+{
+    uint8_t fatno;
+    unsigned c;
+    for (fatno = FAT1 + 1; fatno < bs->fatcnt; fatno++) {
+        for (c = 0; c < nclsts; c++) {
+            fat_set_cluster(bs, dev_handle, fatno, lifo[c],
+                c == 0 ? FAT_CLST_LAST1 : lifo[c - 1]);
+        }
+    }
+}
+/** Allocate clusters in all copies of FAT.
+ *
+ * This function will attempt to allocate the requested number of clusters in
+ * all instances of the FAT.  The FAT will be altered so that the allocated
+ * clusters form an independent chain (i.e. a chain which does not belong to any
+ * file yet).
+ *
+ * @param bs        Buffer holding the boot sector of the file system.
+ * @param dev_handle    Device handle of the file system.
+ * @param nclsts    Number of clusters to allocate.
+ * @param mcl       Output parameter where the first cluster in the chain
+ *          will be returned.
+ * @param lcl       Output parameter where the last cluster in the chain
+ *          will be returned.
+ *
+ * @return      EOK on success, a negative error code otherwise.
+ */
+int
+fat_alloc_clusters(fat_bs_t *bs, dev_handle_t dev_handle, unsigned nclsts,
+    fat_cluster_t *mcl, fat_cluster_t *lcl)
+{
+    uint16_t bps;
+    uint16_t rscnt;
+    uint16_t sf;
+    block_t *blk;
+    fat_cluster_t *lifo;    /* stack for storing free cluster numbers */
+    unsigned found = 0; /* top of the free cluster number stack */
+    unsigned b, c, cl;
+    lifo = (fat_cluster_t *) malloc(nclsts * sizeof(fat_cluster_t));
+    if (!lifo)
+        return ENOMEM;
+    bps = uint16_t_le2host(bs->bps);
+    rscnt = uint16_t_le2host(bs->rscnt);
+    sf = uint16_t_le2host(bs->sec_per_fat);
+    /*
+     * Search FAT1 for unused clusters.
+     */
+    futex_down(&fat_alloc_lock);
+    for (b = 0, cl = 0; b < sf; b++) {
+        blk = block_get(dev_handle, rscnt + b, BLOCK_FLAGS_NONE);
+        for (c = 0; c < bps / sizeof(fat_cluster_t); c++, cl++) {
+            fat_cluster_t *clst = (fat_cluster_t *)blk->data + c;
+            if (uint16_t_le2host(*clst) == FAT_CLST_RES0) {
+                /*
+                 * The cluster is free. Put it into our stack
+                 * of found clusters and mark it as non-free.
+                 */
+                lifo[found] = cl;
+                *clst = (found == 0) ?
+                    host2uint16_t_le(FAT_CLST_LAST1) :
+                    host2uint16_t_le(lifo[found - 1]);
+                blk->dirty = true;  /* need to sync block */
+                if (++found == nclsts) {
+                    /* we are almost done */
+                    block_put(blk);
+                    /* update the shadow copies of FAT */
+                    fat_alloc_shadow_clusters(bs,
+                        dev_handle, lifo, nclsts);
+                    *mcl = lifo[found - 1];
+                    *lcl = lifo[0];
+                    free(lifo);
+                    futex_up(&fat_alloc_lock);
+                    return EOK;
+                }
+            }
+        }
+        block_put(blk);
+    }
+    futex_up(&fat_alloc_lock);
+    /*
+     * We could not find enough clusters. Now we need to free the clusters
+     * we have allocated so far.
+     */
+    while (found--) {
+        fat_set_cluster(bs, dev_handle, FAT1, lifo[found],
+            FAT_CLST_RES0);
+    }
+    free(lifo);
+    return ENOSPC;
+}
+/** Free clusters forming a cluster chain in all copies of FAT.
+ *
+ * @param bs        Buffer hodling the boot sector of the file system.
+ * @param dev_handle    Device handle of the file system.
+ * @param firstc    First cluster in the chain which is to be freed.
+ */
+void
+fat_free_clusters(fat_bs_t *bs, dev_handle_t dev_handle, fat_cluster_t firstc)
+{
+    unsigned fatno;
+    fat_cluster_t nextc;
+    /* Mark all clusters in the chain as free in all copies of FAT. */
+    while (firstc < FAT_CLST_LAST1) {
+        assert(firstc >= FAT_CLST_FIRST && firstc < FAT_CLST_BAD);
+        nextc = fat_get_cluster(bs, dev_handle, firstc);
+        for (fatno = FAT1; fatno < bs->fatcnt; fatno++)
+            fat_set_cluster(bs, dev_handle, fatno, firstc,
+                FAT_CLST_RES0);
+        firstc = nextc;
+    }
+}
+/** Append a cluster chain to the last file cluster in all FATs.
+ *
+ * @param bs        Buffer holding the boot sector of the file system.
+ * @param nodep     Node representing the file.
+ * @param mcl       First cluster of the cluster chain to append.
+ */
+void fat_append_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t mcl)
+{
+    dev_handle_t dev_handle = nodep->idx->dev_handle;
+    fat_cluster_t lcl;
+    uint8_t fatno;
+    if (fat_cluster_walk(bs, dev_handle, nodep->firstc, &lcl,
+        (uint16_t) -1) == 0) {
+        /* No clusters allocated to the node yet. */
+        nodep->firstc = mcl;
+        nodep->dirty = true;        /* need to sync node */
+        return;
+    }
+    for (fatno = FAT1; fatno < bs->fatcnt; fatno++)
+        fat_set_cluster(bs, nodep->idx->dev_handle, fatno, lcl, mcl);
+}
+/** Chop off node clusters in all copies of FAT.
+ *
+ * @param bs        Buffer holding the boot sector of the file system.
+ * @param nodep     FAT node where the chopping will take place.
+ * @param lastc     Last cluster which will remain in the node. If this
+ *          argument is FAT_CLST_RES0, then all clusters will
+ *          be chopped off.
+ */
+void fat_chop_clusters(fat_bs_t *bs, fat_node_t *nodep, fat_cluster_t lastc)
+{
+    dev_handle_t dev_handle = nodep->idx->dev_handle;
+    if (lastc == FAT_CLST_RES0) {
+        /* The node will have zero size and no clusters allocated. */
+        fat_free_clusters(bs, dev_handle, nodep->firstc);
+        nodep->firstc = FAT_CLST_RES0;
+        nodep->dirty = true;        /* need to sync node */
+    } else {
+        fat_cluster_t nextc;
+        unsigned fatno;
+        nextc = fat_get_cluster(bs, dev_handle, lastc);
+        /* Terminate the cluster chain in all copies of FAT. */
+        for (fatno = FAT1; fatno < bs->fatcnt; fatno++)
+            fat_set_cluster(bs, dev_handle, fatno, lastc, FAT_CLST_LAST1);
+        /* Free all following clusters. */
+        fat_free_clusters(bs, dev_handle, nextc);
+    }
+}
+/**
+ * @}
+ */

 /branches/network/uspace/srv/fs/fat/fat_fat.h
 ,0 → 1,91
+/*
+ * Copyright (c) 2008 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 fs
+ * @{
+ */
+#ifndef FAT_FAT_FAT_H_
+#define FAT_FAT_FAT_H_
+#include "../../vfs/vfs.h"
+#include <stdint.h>
+#include <libblock.h>
+#define FAT1        0
+#define FAT_CLST_RES0   0x0000
+#define FAT_CLST_RES1   0x0001
+#define FAT_CLST_FIRST  0x0002
+#define FAT_CLST_BAD    0xfff7
+#define FAT_CLST_LAST1  0xfff8
+#define FAT_CLST_LAST8  0xffff
+/* internally used to mark root directory's parent */
+#define FAT_CLST_ROOTPAR    FAT_CLST_RES0
+/* internally used to mark root directory */
+#define FAT_CLST_ROOT       FAT_CLST_RES1
+/* forward declarations */
+struct block;
+struct fat_node;
+struct fat_bs;
+typedef uint16_t fat_cluster_t;
+#define fat_clusters_get(bs, dh, fc) \
+    fat_cluster_walk((bs), (dh), (fc), NULL, (uint16_t) -1)
+extern uint16_t fat_cluster_walk(struct fat_bs *, dev_handle_t, fat_cluster_t,
+    fat_cluster_t *, uint16_t);
+#define fat_block_get(bs, np, bn, flags) \
+    _fat_block_get((bs), (np)->idx->dev_handle, (np)->firstc, (bn), (flags))
+extern struct block *_fat_block_get(struct fat_bs *, dev_handle_t,
+    fat_cluster_t, bn_t, int);
+extern void fat_append_clusters(struct fat_bs *, struct fat_node *,
+    fat_cluster_t);
+extern void fat_chop_clusters(struct fat_bs *, struct fat_node *,
+    fat_cluster_t);
+extern int fat_alloc_clusters(struct fat_bs *, dev_handle_t, unsigned,
+    fat_cluster_t *, fat_cluster_t *);
+extern void fat_free_clusters(struct fat_bs *, dev_handle_t, fat_cluster_t);
+extern void fat_alloc_shadow_clusters(struct fat_bs *, dev_handle_t,
+    fat_cluster_t *, unsigned);
+extern fat_cluster_t fat_get_cluster(struct fat_bs *, dev_handle_t, fat_cluster_t);
+extern void fat_set_cluster(struct fat_bs *, dev_handle_t, unsigned,
+    fat_cluster_t, fat_cluster_t);
+extern void fat_fill_gap(struct fat_bs *, struct fat_node *, fat_cluster_t,
+    off_t);
+#endif
+/**
+ * @}
+ */

 /branches/network/uspace/srv/fs/fat/fat.c
 ,15 → 49,6
 vfs_info_t fat_vfs_info = {
     .name = "fat",
-    .ops = {
-        [IPC_METHOD_TO_VFS_OP(VFS_LOOKUP)] = VFS_OP_DEFINED,
-        [IPC_METHOD_TO_VFS_OP(VFS_READ)] = VFS_OP_DEFINED,
-        [IPC_METHOD_TO_VFS_OP(VFS_WRITE)] = VFS_OP_NULL,
-        [IPC_METHOD_TO_VFS_OP(VFS_TRUNCATE)] = VFS_OP_NULL,
-        [IPC_METHOD_TO_VFS_OP(VFS_MOUNT)] = VFS_OP_NULL,
-        [IPC_METHOD_TO_VFS_OP(VFS_MOUNTED)] = VFS_OP_DEFINED,
-        [IPC_METHOD_TO_VFS_OP(VFS_UNMOUNT)] = VFS_OP_NULL,
-    }
 };
 fs_reg_t fat_reg;
 ,6 → 101,15
         case VFS_READ:
             fat_read(callid, &call);
             break;
+        case VFS_WRITE:
+            fat_write(callid, &call);
+            break;
+        case VFS_TRUNCATE:
+            fat_truncate(callid, &call);
+            break;
+        case VFS_DESTROY:
+            fat_destroy(callid, &call);
+            break;
         default:
             ipc_answer_0(callid, ENOTSUP);
             break;
 ,16 → 122,16
     int vfs_phone;
     int rc;
-    printf("FAT: HelenOS FAT file system server.\n");
+    printf("fat: HelenOS FAT file system server.\n");
     rc = fat_idx_init();
     if (rc != EOK)
         goto err;
-    vfs_phone = ipc_connect_me_to(PHONE_NS, SERVICE_VFS, 0, 0);
-    while (vfs_phone < EOK) {
-        usleep(10000);
-        vfs_phone = ipc_connect_me_to(PHONE_NS, SERVICE_VFS, 0, 0);
+    vfs_phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_VFS, 0, 0);
+    if (vfs_phone < EOK) {
+        printf("fat: failed to connect to VFS\n");
+        return -1;
     }
     rc = fs_register(vfs_phone, &fat_reg, &fat_vfs_info, fat_connection);

 /branches/network/uspace/srv/fs/fat/fat_ops.c
 ,8 → 36,11
  */
 #include "fat.h"
+#include "fat_dentry.h"
+#include "fat_fat.h"
 #include "../../vfs/vfs.h"
 #include <libfs.h>
+#include <libblock.h>
 #include <ipc/ipc.h>
 #include <ipc/services.h>
 #include <ipc/devmap.h>
 ,10 → 53,8
 #include <assert.h>
 #include <futex.h>
 #include <sys/mman.h>
+#include <align.h>
-#define BS_BLOCK        0
-#define BS_SIZE         512
 /** Futex protecting the list of cached free FAT nodes. */
 static futex_t ffn_futex = FUTEX_INITIALIZER;
 ,216 → 61,6
 /** List of cached free FAT nodes. */
 static LIST_INITIALIZE(ffn_head);
-#define FAT_NAME_LEN        8
-#define FAT_EXT_LEN     3
-#define FAT_PAD         ' '
-#define FAT_DENTRY_UNUSED   0x00
-#define FAT_DENTRY_E5_ESC   0x05
-#define FAT_DENTRY_DOT      0x2e
-#define FAT_DENTRY_ERASED   0xe5
-#define min(a, b)       ((a) < (b) ? (a) : (b))
-static void dentry_name_canonify(fat_dentry_t *d, char *buf)
-{
-    int i;
-    for (i = 0; i < FAT_NAME_LEN; i++) {
-        if (d->name[i] == FAT_PAD)
-            break;
-        if (d->name[i] == FAT_DENTRY_E5_ESC)
-            *buf++ = 0xe5;
-        else
-            *buf++ = d->name[i];
-    }
-    if (d->ext[0] != FAT_PAD)
-        *buf++ = '.';
-    for (i = 0; i < FAT_EXT_LEN; i++) {
-        if (d->ext[i] == FAT_PAD) {
-            *buf = '\0';
-            return;
-        }
-        if (d->ext[i] == FAT_DENTRY_E5_ESC)
-            *buf++ = 0xe5;
-        else
-            *buf++ = d->ext[i];
-    }
-    *buf = '\0';
-}
-static int dev_phone = -1;      /* FIXME */
-static void *dev_buffer = NULL;     /* FIXME */
-/* TODO move somewhere else */
-typedef struct {
-    void *data;
-    size_t size;
-} block_t;
-static block_t *block_get(dev_handle_t dev_handle, off_t offset, size_t bs)
-{
-    /* FIXME */
-    block_t *b;
-    off_t bufpos = 0;
-    size_t buflen = 0;
-    off_t pos = offset * bs;
-    assert(dev_phone != -1);
-    assert(dev_buffer);
-    b = malloc(sizeof(block_t));
-    if (!b)
-        return NULL;
-    b->data = malloc(bs);
-    if (!b->data) {
-        free(b);
-        return NULL;
-    }
-    b->size = bs;
-    if (!libfs_blockread(dev_phone, dev_buffer, &bufpos, &buflen, &pos,
-        b->data, bs, bs)) {
-        free(b->data);
-        free(b);
-        return NULL;
-    }
-    return b;
-}
-static void block_put(block_t *block)
-{
-    /* FIXME */
-    free(block->data);
-    free(block);
-}
-#define FAT_BS(b)       ((fat_bs_t *)((b)->data))
-#define FAT_CLST_RES0   0x0000
-#define FAT_CLST_RES1   0x0001
-#define FAT_CLST_FIRST  0x0002
-#define FAT_CLST_BAD    0xfff7
-#define FAT_CLST_LAST1  0xfff8
-#define FAT_CLST_LAST8  0xffff
-/* internally used to mark root directory's parent */
-#define FAT_CLST_ROOTPAR    FAT_CLST_RES0
-/* internally used to mark root directory */
-#define FAT_CLST_ROOT       FAT_CLST_RES1
-#define fat_block_get(np, off) \
-    _fat_block_get((np)->idx->dev_handle, (np)->firstc, (off))
-static block_t *
-_fat_block_get(dev_handle_t dev_handle, fat_cluster_t firstc, off_t offset)
-{
-    block_t *bb;
-    block_t *b;
-    unsigned bps;
-    unsigned spc;
-    unsigned rscnt;     /* block address of the first FAT */
-    unsigned fatcnt;
-    unsigned rde;
-    unsigned rds;       /* root directory size */
-    unsigned sf;
-    unsigned ssa;       /* size of the system area */
-    unsigned clusters;
-    fat_cluster_t clst = firstc;
-    unsigned i;
-    bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
-    bps = uint16_t_le2host(FAT_BS(bb)->bps);
-    spc = FAT_BS(bb)->spc;
-    rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);
-    fatcnt = FAT_BS(bb)->fatcnt;
-    rde = uint16_t_le2host(FAT_BS(bb)->root_ent_max);
-    sf = uint16_t_le2host(FAT_BS(bb)->sec_per_fat);
-    block_put(bb);
-    rds = (sizeof(fat_dentry_t) * rde) / bps;
-    rds += ((sizeof(fat_dentry_t) * rde) % bps != 0);
-    ssa = rscnt + fatcnt * sf + rds;
-    if (firstc == FAT_CLST_ROOT) {
-        /* root directory special case */
-        assert(offset < rds);
-        b = block_get(dev_handle, rscnt + fatcnt * sf + offset, bps);
-        return b;
-    }
-    clusters = offset / spc;
-    for (i = 0; i < clusters; i++) {
-        unsigned fsec;  /* sector offset relative to FAT1 */
-        unsigned fidx;  /* FAT1 entry index */
-        assert(clst >= FAT_CLST_FIRST && clst < FAT_CLST_BAD);
-        fsec = (clst * sizeof(fat_cluster_t)) / bps;
-        fidx = clst % (bps / sizeof(fat_cluster_t));
-        /* read FAT1 */
-        b = block_get(dev_handle, rscnt + fsec, bps);
-        clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]);
-        assert(clst != FAT_CLST_BAD);
-        assert(clst < FAT_CLST_LAST1);
-        block_put(b);
-    }
-    b = block_get(dev_handle, ssa + (clst - FAT_CLST_FIRST) * spc +
-        offset % spc, bps);
-    return b;
-}
-/** Return number of blocks allocated to a file.
- *
- * @param dev_handle    Device handle of the device with the file.
- * @param firstc    First cluster of the file.
- *
- * @return      Number of blocks allocated to the file.
- */
-static uint16_t
-_fat_blcks_get(dev_handle_t dev_handle, fat_cluster_t firstc)
-{
-    block_t *bb;
-    block_t *b;
-    unsigned bps;
-    unsigned spc;
-    unsigned rscnt;     /* block address of the first FAT */
-    unsigned clusters = 0;
-    fat_cluster_t clst = firstc;
-    bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
-    bps = uint16_t_le2host(FAT_BS(bb)->bps);
-    spc = FAT_BS(bb)->spc;
-    rscnt = uint16_t_le2host(FAT_BS(bb)->rscnt);
-    block_put(bb);
-    if (firstc == FAT_CLST_RES0) {
-        /* No space allocated to the file. */
-        return 0;
-    }
-    while (clst < FAT_CLST_LAST1) {
-        unsigned fsec;  /* sector offset relative to FAT1 */
-        unsigned fidx;  /* FAT1 entry index */
-        assert(clst >= FAT_CLST_FIRST);
-        fsec = (clst * sizeof(fat_cluster_t)) / bps;
-        fidx = clst % (bps / sizeof(fat_cluster_t));
-        /* read FAT1 */
-        b = block_get(dev_handle, rscnt + fsec, bps);
-        clst = uint16_t_le2host(((fat_cluster_t *)b->data)[fidx]);
-        assert(clst != FAT_CLST_BAD);
-        block_put(b);
-        clusters++;
-    }
-    return clusters * spc;
-}
 static void fat_node_initialize(fat_node_t *node)
 {
     futex_initialize(&node->lock, 1);
 ,52 → 73,73
     node->dirty = false;
 }
-static uint16_t fat_bps_get(dev_handle_t dev_handle)
+static void fat_node_sync(fat_node_t *node)
 {
-    block_t *bb;
+    block_t *b;
+    fat_bs_t *bs;
+    fat_dentry_t *d;
     uint16_t bps;
+    unsigned dps;
-    bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
-    assert(bb != NULL);
-    bps = uint16_t_le2host(FAT_BS(bb)->bps);
-    block_put(bb);
+    assert(node->dirty);
-    return bps;
-}
+    bs = block_bb_get(node->idx->dev_handle);
+    bps = uint16_t_le2host(bs->bps);
+    dps = bps / sizeof(fat_dentry_t);
+    /* Read the block that contains the dentry of interest. */
+    b = _fat_block_get(bs, node->idx->dev_handle, node->idx->pfc,
+        (node->idx->pdi * sizeof(fat_dentry_t)) / bps, BLOCK_FLAGS_NONE);
-typedef enum {
-    FAT_DENTRY_SKIP,
-    FAT_DENTRY_LAST,
-    FAT_DENTRY_VALID
-} fat_dentry_clsf_t;
+    d = ((fat_dentry_t *)b->data) + (node->idx->pdi % dps);
-static fat_dentry_clsf_t fat_classify_dentry(fat_dentry_t *d)
-{
-    if (d->attr & FAT_ATTR_VOLLABEL) {
-        /* volume label entry */
-        return FAT_DENTRY_SKIP;
+    d->firstc = host2uint16_t_le(node->firstc);
+    if (node->type == FAT_FILE) {
+        d->size = host2uint32_t_le(node->size);
+    } else if (node->type == FAT_DIRECTORY) {
+        d->attr = FAT_ATTR_SUBDIR;
     }
-    if (d->name[0] == FAT_DENTRY_ERASED) {
-        /* not-currently-used entry */
-        return FAT_DENTRY_SKIP;
-    }
-    if (d->name[0] == FAT_DENTRY_UNUSED) {
-        /* never used entry */
-        return FAT_DENTRY_LAST;
-    }
-    if (d->name[0] == FAT_DENTRY_DOT) {
-        /*
-         * Most likely '.' or '..'.
-         * It cannot occur in a regular file name.
-         */
-        return FAT_DENTRY_SKIP;
-    }
-    return FAT_DENTRY_VALID;
+    /* TODO: update other fields? (e.g time fields) */
+    b->dirty = true;        /* need to sync block */
+    block_put(b);
 }
-static void fat_node_sync(fat_node_t *node)
+static fat_node_t *fat_node_get_new(void)
 {
-    /* TODO */
+    fat_node_t *nodep;
+    futex_down(&ffn_futex);
+    if (!list_empty(&ffn_head)) {
+        /* Try to use a cached free node structure. */
+        fat_idx_t *idxp_tmp;
+        nodep = list_get_instance(ffn_head.next, fat_node_t, ffn_link);
+        if (futex_trydown(&nodep->lock) == ESYNCH_WOULD_BLOCK)
+            goto skip_cache;
+        idxp_tmp = nodep->idx;
+        if (futex_trydown(&idxp_tmp->lock) == ESYNCH_WOULD_BLOCK) {
+            futex_up(&nodep->lock);
+            goto skip_cache;
+        }
+        list_remove(&nodep->ffn_link);
+        futex_up(&ffn_futex);
+        if (nodep->dirty)
+            fat_node_sync(nodep);
+        idxp_tmp->nodep = NULL;
+        futex_up(&nodep->lock);
+        futex_up(&idxp_tmp->lock);
+    } else {
+skip_cache:
+        /* Try to allocate a new node structure. */
+        futex_up(&ffn_futex);
+        nodep = (fat_node_t *)malloc(sizeof(fat_node_t));
+        if (!nodep)
+            return NULL;
+    }
+    fat_node_initialize(nodep);
+    return nodep;
 }
 /** Internal version of fat_node_get().
 ,9 → 149,11
 static void *fat_node_get_core(fat_idx_t *idxp)
 {
     block_t *b;
+    fat_bs_t *bs;
     fat_dentry_t *d;
     fat_node_t *nodep = NULL;
     unsigned bps;
+    unsigned spc;
     unsigned dps;
     if (idxp->nodep) {
 ,41 → 174,18
     assert(idxp->pfc);
-    futex_down(&ffn_futex);
-    if (!list_empty(&ffn_head)) {
-        /* Try to use a cached free node structure. */
-        fat_idx_t *idxp_tmp;
-        nodep = list_get_instance(ffn_head.next, fat_node_t, ffn_link);
-        if (futex_trydown(&nodep->lock) == ESYNCH_WOULD_BLOCK)
-            goto skip_cache;
-        idxp_tmp = nodep->idx;
-        if (futex_trydown(&idxp_tmp->lock) == ESYNCH_WOULD_BLOCK) {
-            futex_up(&nodep->lock);
-            goto skip_cache;
-        }
-        list_remove(&nodep->ffn_link);
-        futex_up(&ffn_futex);
-        if (nodep->dirty)
-            fat_node_sync(nodep);
-        idxp_tmp->nodep = NULL;
-        futex_up(&nodep->lock);
-        futex_up(&idxp_tmp->lock);
-    } else {
-skip_cache:
-        /* Try to allocate a new node structure. */
-        futex_up(&ffn_futex);
-        nodep = (fat_node_t *)malloc(sizeof(fat_node_t));
-        if (!nodep)
-            return NULL;
-    }
-    fat_node_initialize(nodep);
+    nodep = fat_node_get_new();
+    if (!nodep)
+        return NULL;
-    bps = fat_bps_get(idxp->dev_handle);
+    bs = block_bb_get(idxp->dev_handle);
+    bps = uint16_t_le2host(bs->bps);
+    spc = bs->spc;
     dps = bps / sizeof(fat_dentry_t);
     /* Read the block that contains the dentry of interest. */
-    b = _fat_block_get(idxp->dev_handle, idxp->pfc,
-        (idxp->pdi * sizeof(fat_dentry_t)) / bps);
+    b = _fat_block_get(bs, idxp->dev_handle, idxp->pfc,
+        (idxp->pdi * sizeof(fat_dentry_t)) / bps, BLOCK_FLAGS_NONE);
     assert(b);
     d = ((fat_dentry_t *)b->data) + (idxp->pdi % dps);
 ,7 → 201,7
          * defined for the directory entry type. We must determine the
          * size of the directory by walking the FAT.
          */
-        nodep->size = bps * _fat_blcks_get(idxp->dev_handle,
+        nodep->size = bps * spc * fat_clusters_get(bs, idxp->dev_handle,
             uint16_t_le2host(d->firstc));
     } else {
         nodep->type = FAT_FILE;
 ,8 → 220,31
     return nodep;
 }
+/*
+ * Forward declarations of FAT libfs operations.
+ */
+static void *fat_node_get(dev_handle_t, fs_index_t);
+static void fat_node_put(void *);
+static void *fat_create_node(dev_handle_t, int);
+static int fat_destroy_node(void *);
+static int fat_link(void *, void *, const char *);
+static int fat_unlink(void *, void *);
+static void *fat_match(void *, const char *);
+static fs_index_t fat_index_get(void *);
+static size_t fat_size_get(void *);
+static unsigned fat_lnkcnt_get(void *);
+static bool fat_has_children(void *);
+static void *fat_root_get(dev_handle_t);
+static char fat_plb_get_char(unsigned);
+static bool fat_is_directory(void *);
+static bool fat_is_file(void *node);
+/*
+ * FAT libfs operations.
+ */
 /** Instantiate a FAT in-core node. */
-static void *fat_node_get(dev_handle_t dev_handle, fs_index_t index)
+void *fat_node_get(dev_handle_t dev_handle, fs_index_t index)
 {
     void *node;
     fat_idx_t *idxp;
 ,41 → 258,318
     return node;
 }
-static void fat_node_put(void *node)
+void fat_node_put(void *node)
 {
     fat_node_t *nodep = (fat_node_t *)node;
+    bool destroy = false;
     futex_down(&nodep->lock);
     if (!--nodep->refcnt) {
-        futex_down(&ffn_futex);
-        list_append(&nodep->ffn_link, &ffn_head);
-        futex_up(&ffn_futex);
+        if (nodep->idx) {
+            futex_down(&ffn_futex);
+            list_append(&nodep->ffn_link, &ffn_head);
+            futex_up(&ffn_futex);
+        } else {
+            /*
+             * The node does not have any index structure associated
+             * with itself. This can only mean that we are releasing
+             * the node after a failed attempt to allocate the index
+             * structure for it.
+             */
+            destroy = true;
+        }
     }
     futex_up(&nodep->lock);
+    if (destroy)
+        free(node);
 }
-static void *fat_create(int flags)
+void *fat_create_node(dev_handle_t dev_handle, int flags)
 {
-    return NULL;    /* not supported at the moment */
+    fat_idx_t *idxp;
+    fat_node_t *nodep;
+    fat_bs_t *bs;
+    fat_cluster_t mcl, lcl;
+    uint16_t bps;
+    int rc;
+    bs = block_bb_get(dev_handle);
+    bps = uint16_t_le2host(bs->bps);
+    if (flags & L_DIRECTORY) {
+        /* allocate a cluster */
+        rc = fat_alloc_clusters(bs, dev_handle, 1, &mcl, &lcl);
+        if (rc != EOK)
+            return NULL;
+    }
+    nodep = fat_node_get_new();
+    if (!nodep) {
+        fat_free_clusters(bs, dev_handle, mcl);
+        return NULL;
+    }
+    idxp = fat_idx_get_new(dev_handle);
+    if (!idxp) {
+        fat_free_clusters(bs, dev_handle, mcl);
+        fat_node_put(nodep);
+        return NULL;
+    }
+    /* idxp->lock held */
+    if (flags & L_DIRECTORY) {
+        int i;
+        block_t *b;
+        /*
+         * Populate the new cluster with unused dentries.
+         */
+        for (i = 0; i < bs->spc; i++) {
+            b = _fat_block_get(bs, dev_handle, mcl, i,
+                BLOCK_FLAGS_NOREAD);
+            /* mark all dentries as never-used */
+            memset(b->data, 0, bps);
+            b->dirty = false;
+            block_put(b);
+        }
+        nodep->type = FAT_DIRECTORY;
+        nodep->firstc = mcl;
+        nodep->size = bps * bs->spc;
+    } else {
+        nodep->type = FAT_FILE;
+        nodep->firstc = FAT_CLST_RES0;
+        nodep->size = 0;
+    }
+    nodep->lnkcnt = 0;  /* not linked anywhere */
+    nodep->refcnt = 1;
+    nodep->dirty = true;
+    nodep->idx = idxp;
+    idxp->nodep = nodep;
+    futex_up(&idxp->lock);
+    return nodep;
 }
-static int fat_destroy(void *node)
+int fat_destroy_node(void *node)
 {
-    return ENOTSUP; /* not supported at the moment */
+    fat_node_t *nodep = (fat_node_t *)node;
+    fat_bs_t *bs;
+    /*
+     * The node is not reachable from the file system. This means that the
+     * link count should be zero and that the index structure cannot be
+     * found in the position hash. Obviously, we don't need to lock the node
+     * nor its index structure.
+     */
+    assert(nodep->lnkcnt == 0);
+    /*
+     * The node may not have any children.
+     */
+    assert(fat_has_children(node) == false);
+    bs = block_bb_get(nodep->idx->dev_handle);
+    if (nodep->firstc != FAT_CLST_RES0) {
+        assert(nodep->size);
+        /* Free all clusters allocated to the node. */
+        fat_free_clusters(bs, nodep->idx->dev_handle, nodep->firstc);
+    }
+    fat_idx_destroy(nodep->idx);
+    free(nodep);
+    return EOK;
 }
-static bool fat_link(void *prnt, void *chld, const char *name)
+int fat_link(void *prnt, void *chld, const char *name)
 {
-    return false;   /* not supported at the moment */
+    fat_node_t *parentp = (fat_node_t *)prnt;
+    fat_node_t *childp = (fat_node_t *)chld;
+    fat_dentry_t *d;
+    fat_bs_t *bs;
+    block_t *b;
+    int i, j;
+    uint16_t bps;
+    unsigned dps;
+    unsigned blocks;
+    fat_cluster_t mcl, lcl;
+    int rc;
+    futex_down(&childp->lock);
+    if (childp->lnkcnt == 1) {
+        /*
+         * On FAT, we don't support multiple hard links.
+         */
+        futex_up(&childp->lock);
+        return EMLINK;
+    }
+    assert(childp->lnkcnt == 0);
+    futex_up(&childp->lock);
+    if (!fat_dentry_name_verify(name)) {
+        /*
+         * Attempt to create unsupported name.
+         */
+        return ENOTSUP;
+    }
+    /*
+     * Get us an unused parent node's dentry or grow the parent and allocate
+     * a new one.
+     */
+    futex_down(&parentp->idx->lock);
+    bs = block_bb_get(parentp->idx->dev_handle);
+    bps = uint16_t_le2host(bs->bps);
+    dps = bps / sizeof(fat_dentry_t);
+    blocks = parentp->size / bps;
+    for (i = 0; i < blocks; i++) {
+        b = fat_block_get(bs, parentp, i, BLOCK_FLAGS_NONE);
+        for (j = 0; j < dps; j++) {
+            d = ((fat_dentry_t *)b->data) + j;
+            switch (fat_classify_dentry(d)) {
+            case FAT_DENTRY_SKIP:
+            case FAT_DENTRY_VALID:
+                /* skipping used and meta entries */
+                continue;
+            case FAT_DENTRY_FREE:
+            case FAT_DENTRY_LAST:
+                /* found an empty slot */
+                goto hit;
+            }
+        }
+        block_put(b);
+    }
+    j = 0;
+    /*
+     * We need to grow the parent in order to create a new unused dentry.
+     */
+    if (parentp->idx->pfc == FAT_CLST_ROOT) {
+        /* Can't grow the root directory. */
+        futex_up(&parentp->idx->lock);
+        return ENOSPC;
+    }
+    rc = fat_alloc_clusters(bs, parentp->idx->dev_handle, 1, &mcl, &lcl);
+    if (rc != EOK) {
+        futex_up(&parentp->idx->lock);
+        return rc;
+    }
+    fat_append_clusters(bs, parentp, mcl);
+    b = fat_block_get(bs, parentp, i, BLOCK_FLAGS_NOREAD);
+    d = (fat_dentry_t *)b->data;
+    /*
+     * Clear all dentries in the block except for the first one (the first
+     * dentry will be cleared in the next step).
+     */
+    memset(d + 1, 0, bps - sizeof(fat_dentry_t));
+hit:
+    /*
+     * At this point we only establish the link between the parent and the
+     * child.  The dentry, except of the name and the extension, will remain
+     * uninitialized until the corresponding node is synced. Thus the valid
+     * dentry data is kept in the child node structure.
+     */
+    memset(d, 0, sizeof(fat_dentry_t));
+    fat_dentry_name_set(d, name);
+    b->dirty = true;        /* need to sync block */
+    block_put(b);
+    futex_up(&parentp->idx->lock);
+    futex_down(&childp->idx->lock);
+    /*
+     * If possible, create the Sub-directory Identifier Entry and the
+     * Sub-directory Parent Pointer Entry (i.e. "." and ".."). These entries
+     * are not mandatory according to Standard ECMA-107 and HelenOS VFS does
+     * not use them anyway, so this is rather a sign of our good will.
+     */
+    b = fat_block_get(bs, childp, 0, BLOCK_FLAGS_NONE);
+    d = (fat_dentry_t *)b->data;
+    if (fat_classify_dentry(d) == FAT_DENTRY_LAST ||
+        strcmp(d->name, FAT_NAME_DOT) == 0) {
+        memset(d, 0, sizeof(fat_dentry_t));
+        strcpy(d->name, FAT_NAME_DOT);
+        strcpy(d->ext, FAT_EXT_PAD);
+        d->attr = FAT_ATTR_SUBDIR;
+        d->firstc = host2uint16_t_le(childp->firstc);
+        /* TODO: initialize also the date/time members. */
+    }
+    d++;
+    if (fat_classify_dentry(d) == FAT_DENTRY_LAST ||
+        strcmp(d->name, FAT_NAME_DOT_DOT) == 0) {
+        memset(d, 0, sizeof(fat_dentry_t));
+        strcpy(d->name, FAT_NAME_DOT_DOT);
+        strcpy(d->ext, FAT_EXT_PAD);
+        d->attr = FAT_ATTR_SUBDIR;
+        d->firstc = (parentp->firstc == FAT_CLST_ROOT) ?
+            host2uint16_t_le(FAT_CLST_RES0) :
+            host2uint16_t_le(parentp->firstc);
+        /* TODO: initialize also the date/time members. */
+    }
+    b->dirty = true;        /* need to sync block */
+    block_put(b);
+    childp->idx->pfc = parentp->firstc;
+    childp->idx->pdi = i * dps + j;
+    futex_up(&childp->idx->lock);
+    futex_down(&childp->lock);
+    childp->lnkcnt = 1;
+    childp->dirty = true;       /* need to sync node */
+    futex_up(&childp->lock);
+    /*
+     * Hash in the index structure into the position hash.
+     */
+    fat_idx_hashin(childp->idx);
+    return EOK;
 }
-static int fat_unlink(void *prnt, void *chld)
+int fat_unlink(void *prnt, void *chld)
 {
-    return ENOTSUP; /* not supported at the moment */
+    fat_node_t *parentp = (fat_node_t *)prnt;
+    fat_node_t *childp = (fat_node_t *)chld;
+    fat_bs_t *bs;
+    fat_dentry_t *d;
+    uint16_t bps;
+    block_t *b;
+    futex_down(&parentp->lock);
+    futex_down(&childp->lock);
+    assert(childp->lnkcnt == 1);
+    futex_down(&childp->idx->lock);
+    bs = block_bb_get(childp->idx->dev_handle);
+    bps = uint16_t_le2host(bs->bps);
+    b = _fat_block_get(bs, childp->idx->dev_handle, childp->idx->pfc,
+        (childp->idx->pdi * sizeof(fat_dentry_t)) / bps,
+        BLOCK_FLAGS_NONE);
+    d = (fat_dentry_t *)b->data +
+        (childp->idx->pdi % (bps / sizeof(fat_dentry_t)));
+    /* mark the dentry as not-currently-used */
+    d->name[0] = FAT_DENTRY_ERASED;
+    b->dirty = true;        /* need to sync block */
+    block_put(b);
+    /* remove the index structure from the position hash */
+    fat_idx_hashout(childp->idx);
+    /* clear position information */
+    childp->idx->pfc = FAT_CLST_RES0;
+    childp->idx->pdi = 0;
+    futex_up(&childp->idx->lock);
+    childp->lnkcnt = 0;
+    childp->dirty = true;
+    futex_up(&childp->lock);
+    futex_up(&parentp->lock);
+    return EOK;
 }
-static void *fat_match(void *prnt, const char *component)
+void *fat_match(void *prnt, const char *component)
 {
+    fat_bs_t *bs;
     fat_node_t *parentp = (fat_node_t *)prnt;
     char name[FAT_NAME_LEN + 1 + FAT_EXT_LEN + 1];
     unsigned i, j;
 ,20 → 580,17
     block_t *b;
     futex_down(&parentp->idx->lock);
-    bps = fat_bps_get(parentp->idx->dev_handle);
+    bs = block_bb_get(parentp->idx->dev_handle);
+    bps = uint16_t_le2host(bs->bps);
     dps = bps / sizeof(fat_dentry_t);
-    blocks = parentp->size / bps + (parentp->size % bps != 0);
+    blocks = parentp->size / bps;
     for (i = 0; i < blocks; i++) {
-        unsigned dentries;
-        b = fat_block_get(parentp, i);
-        dentries = (i == blocks - 1) ?
-            parentp->size % sizeof(fat_dentry_t) :
-            dps;
-        for (j = 0; j < dentries; j++) {
+        b = fat_block_get(bs, parentp, i, BLOCK_FLAGS_NONE);
+        for (j = 0; j < dps; j++) {
             d = ((fat_dentry_t *)b->data) + j;
             switch (fat_classify_dentry(d)) {
             case FAT_DENTRY_SKIP:
+            case FAT_DENTRY_FREE:
                 continue;
             case FAT_DENTRY_LAST:
                 block_put(b);
 ,10 → 598,10
                 return NULL;
             default:
             case FAT_DENTRY_VALID:
-                dentry_name_canonify(d, name);
+                fat_dentry_name_get(d, name);
                 break;
             }
-            if (stricmp(name, component) == 0) {
+            if (fat_dentry_namecmp(name, component) == 0) {
                 /* hit */
                 void *node;
                 /*
 ,11 → 630,12
         }
         block_put(b);
     }
     futex_up(&parentp->idx->lock);
     return NULL;
 }
-static fs_index_t fat_index_get(void *node)
+fs_index_t fat_index_get(void *node)
 {
     fat_node_t *fnodep = (fat_node_t *)node;
     if (!fnodep)
 ,18 → 643,19
     return fnodep->idx->index;
 }
-static size_t fat_size_get(void *node)
+size_t fat_size_get(void *node)
 {
     return ((fat_node_t *)node)->size;
 }
-static unsigned fat_lnkcnt_get(void *node)
+unsigned fat_lnkcnt_get(void *node)
 {
     return ((fat_node_t *)node)->lnkcnt;
 }
-static bool fat_has_children(void *node)
+bool fat_has_children(void *node)
 {
+    fat_bs_t *bs;
     fat_node_t *nodep = (fat_node_t *)node;
     unsigned bps;
     unsigned dps;
 ,25 → 665,23
     if (nodep->type != FAT_DIRECTORY)
         return false;
     futex_down(&nodep->idx->lock);
-    bps = fat_bps_get(nodep->idx->dev_handle);
+    bs = block_bb_get(nodep->idx->dev_handle);
+    bps = uint16_t_le2host(bs->bps);
     dps = bps / sizeof(fat_dentry_t);
-    blocks = nodep->size / bps + (nodep->size % bps != 0);
+    blocks = nodep->size / bps;
     for (i = 0; i < blocks; i++) {
-        unsigned dentries;
         fat_dentry_t *d;
-        b = fat_block_get(nodep, i);
-        dentries = (i == blocks - 1) ?
-            nodep->size % sizeof(fat_dentry_t) :
-            dps;
-        for (j = 0; j < dentries; j++) {
+        b = fat_block_get(bs, nodep, i, BLOCK_FLAGS_NONE);
+        for (j = 0; j < dps; j++) {
             d = ((fat_dentry_t *)b->data) + j;
             switch (fat_classify_dentry(d)) {
             case FAT_DENTRY_SKIP:
+            case FAT_DENTRY_FREE:
                 continue;
             case FAT_DENTRY_LAST:
                 block_put(b);
 ,22 → 704,22
     return false;
 }
-static void *fat_root_get(dev_handle_t dev_handle)
+void *fat_root_get(dev_handle_t dev_handle)
 {
     return fat_node_get(dev_handle, 0);
 }
-static char fat_plb_get_char(unsigned pos)
+char fat_plb_get_char(unsigned pos)
 {
     return fat_reg.plb_ro[pos % PLB_SIZE];
 }
-static bool fat_is_directory(void *node)
+bool fat_is_directory(void *node)
 {
     return ((fat_node_t *)node)->type == FAT_DIRECTORY;
 }
-static bool fat_is_file(void *node)
+bool fat_is_file(void *node)
 {
     return ((fat_node_t *)node)->type == FAT_FILE;
 }
 ,8 → 729,8
     .match = fat_match,
     .node_get = fat_node_get,
     .node_put = fat_node_put,
-    .create = fat_create,
-    .destroy = fat_destroy,
+    .create = fat_create_node,
+    .destroy = fat_destroy_node,
     .link = fat_link,
     .unlink = fat_unlink,
     .index_get = fat_index_get,
 ,60 → 743,57
     .is_file = fat_is_file
 };
+/*
+ * VFS operations.
+ */
 void fat_mounted(ipc_callid_t rid, ipc_call_t *request)
 {
     dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
-    block_t *bb;
+    fat_bs_t *bs;
     uint16_t bps;
     uint16_t rde;
     int rc;
-    /*
-     * For now, we don't bother to remember dev_handle, dev_phone or
-     * dev_buffer in some data structure. We use global variables because we
-     * know there will be at most one mount on this file system.
-     * Of course, this is a huge TODO item.
-     */
-    dev_buffer = mmap(NULL, BS_SIZE, PROTO_READ | PROTO_WRITE,
-        MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
-    if (!dev_buffer) {
-        ipc_answer_0(rid, ENOMEM);
+    /* initialize libblock */
+    rc = block_init(dev_handle, BS_SIZE);
+    if (rc != EOK) {
+        ipc_answer_0(rid, rc);
         return;
     }
-    dev_phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP,
-        DEVMAP_CONNECT_TO_DEVICE, dev_handle);
-    if (dev_phone < 0) {
-        munmap(dev_buffer, BS_SIZE);
-        ipc_answer_0(rid, dev_phone);
-        return;
-    }
-    rc = ipc_share_out_start(dev_phone, dev_buffer,
-        AS_AREA_READ | AS_AREA_WRITE);
+    /* prepare the boot block */
+    rc = block_bb_read(dev_handle, BS_BLOCK * BS_SIZE, BS_SIZE);
     if (rc != EOK) {
-            munmap(dev_buffer, BS_SIZE);
+        block_fini(dev_handle);
         ipc_answer_0(rid, rc);
         return;
     }
+    /* get the buffer with the boot sector */
+    bs = block_bb_get(dev_handle);
     /* Read the number of root directory entries. */
-    bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
-    bps = uint16_t_le2host(FAT_BS(bb)->bps);
-    rde = uint16_t_le2host(FAT_BS(bb)->root_ent_max);
-    block_put(bb);
+    bps = uint16_t_le2host(bs->bps);
+    rde = uint16_t_le2host(bs->root_ent_max);
     if (bps != BS_SIZE) {
-        munmap(dev_buffer, BS_SIZE);
+        block_fini(dev_handle);
         ipc_answer_0(rid, ENOTSUP);
         return;
     }
+    /* Initialize the block cache */
+    rc = block_cache_init(dev_handle, bps, 0 /* XXX */);
+    if (rc != EOK) {
+        block_fini(dev_handle);
+        ipc_answer_0(rid, rc);
+        return;
+    }
     rc = fat_idx_init_by_dev_handle(dev_handle);
     if (rc != EOK) {
-            munmap(dev_buffer, BS_SIZE);
+        block_fini(dev_handle);
         ipc_answer_0(rid, rc);
         return;
     }
 ,7 → 801,7
     /* Initialize the root node. */
     fat_node_t *rootp = (fat_node_t *)malloc(sizeof(fat_node_t));
     if (!rootp) {
-            munmap(dev_buffer, BS_SIZE);
+        block_fini(dev_handle);
         fat_idx_fini_by_dev_handle(dev_handle);
         ipc_answer_0(rid, ENOMEM);
         return;
 ,7 → 810,7
     fat_idx_t *ridxp = fat_idx_get_by_pos(dev_handle, FAT_CLST_ROOTPAR, 0);
     if (!ridxp) {
-            munmap(dev_buffer, BS_SIZE);
+        block_fini(dev_handle);
         free(rootp);
         fat_idx_fini_by_dev_handle(dev_handle);
         ipc_answer_0(rid, ENOMEM);
 ,7 → 848,8
     fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
     off_t pos = (off_t)IPC_GET_ARG3(*request);
     fat_node_t *nodep = (fat_node_t *)fat_node_get(dev_handle, index);
-    uint16_t bps = fat_bps_get(dev_handle);
+    fat_bs_t *bs;
+    uint16_t bps;
     size_t bytes;
     block_t *b;
 ,6 → 867,9
         return;
     }
+    bs = block_bb_get(dev_handle);
+    bps = uint16_t_le2host(bs->bps);
     if (nodep->type == FAT_FILE) {
         /*
          * Our strategy for regular file reads is to read one block at
 ,11 → 876,19
          * most and make use of the possibility to return less data than
          * requested. This keeps the code very simple.
          */
-        bytes = min(len, bps - pos % bps);
-        b = fat_block_get(nodep, pos / bps);
-        (void) ipc_data_read_finalize(callid, b->data + pos % bps,
-            bytes);
-        block_put(b);
+        if (pos >= nodep->size) {
+            /* reading beyond the EOF */
+            bytes = 0;
+            (void) ipc_data_read_finalize(callid, NULL, 0);
+        } else {
+            bytes = min(len, bps - pos % bps);
+            bytes = min(bytes, nodep->size - pos);
+            b = fat_block_get(bs, nodep, pos / bps,
+                BLOCK_FLAGS_NONE);
+            (void) ipc_data_read_finalize(callid, b->data + pos % bps,
+                bytes);
+            block_put(b);
+        }
     } else {
         unsigned bnum;
         off_t spos = pos;
 ,7 → 909,7
         while (bnum < nodep->size / bps) {
             off_t o;
-            b = fat_block_get(nodep, bnum);
+            b = fat_block_get(bs, nodep, bnum, BLOCK_FLAGS_NONE);
             for (o = pos % (bps / sizeof(fat_dentry_t));
                 o < bps / sizeof(fat_dentry_t);
                 o++, pos++) {
 ,6 → 916,7
                 d = ((fat_dentry_t *)b->data) + o;
                 switch (fat_classify_dentry(d)) {
                 case FAT_DENTRY_SKIP:
+                case FAT_DENTRY_FREE:
                     continue;
                 case FAT_DENTRY_LAST:
                     block_put(b);
 ,7 → 923,7
                     goto miss;
                 default:
                 case FAT_DENTRY_VALID:
-                    dentry_name_canonify(d, name);
+                    fat_dentry_name_get(d, name);
                     block_put(b);
                     goto hit;
                 }
 ,6 → 945,186
     ipc_answer_1(rid, EOK, (ipcarg_t)bytes);
 }
+void fat_write(ipc_callid_t rid, ipc_call_t *request)
+{
+    dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
+    fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
+    off_t pos = (off_t)IPC_GET_ARG3(*request);
+    fat_node_t *nodep = (fat_node_t *)fat_node_get(dev_handle, index);
+    fat_bs_t *bs;
+    size_t bytes;
+    block_t *b;
+    uint16_t bps;
+    unsigned spc;
+    unsigned bpc;       /* bytes per cluster */
+    off_t boundary;
+    int flags = BLOCK_FLAGS_NONE;
+    if (!nodep) {
+        ipc_answer_0(rid, ENOENT);
+        return;
+    }
+    ipc_callid_t callid;
+    size_t len;
+    if (!ipc_data_write_receive(&callid, &len)) {
+        fat_node_put(nodep);
+        ipc_answer_0(callid, EINVAL);
+        ipc_answer_0(rid, EINVAL);
+        return;
+    }
+    bs = block_bb_get(dev_handle);
+    bps = uint16_t_le2host(bs->bps);
+    spc = bs->spc;
+    bpc = bps * spc;
+    /*
+     * In all scenarios, we will attempt to write out only one block worth
+     * of data at maximum. There might be some more efficient approaches,
+     * but this one greatly simplifies fat_write(). Note that we can afford
+     * to do this because the client must be ready to handle the return
+     * value signalizing a smaller number of bytes written.
+     */
+    bytes = min(len, bps - pos % bps);
+    if (bytes == bps)
+        flags |= BLOCK_FLAGS_NOREAD;
+    boundary = ROUND_UP(nodep->size, bpc);
+    if (pos < boundary) {
+        /*
+         * This is the easier case - we are either overwriting already
+         * existing contents or writing behind the EOF, but still within
+         * the limits of the last cluster. The node size may grow to the
+         * next block size boundary.
+         */
+        fat_fill_gap(bs, nodep, FAT_CLST_RES0, pos);
+        b = fat_block_get(bs, nodep, pos / bps, flags);
+        (void) ipc_data_write_finalize(callid, b->data + pos % bps,
+            bytes);
+        b->dirty = true;        /* need to sync block */
+        block_put(b);
+        if (pos + bytes > nodep->size) {
+            nodep->size = pos + bytes;
+            nodep->dirty = true;    /* need to sync node */
+        }
+        ipc_answer_2(rid, EOK, bytes, nodep->size);
+        fat_node_put(nodep);
+        return;
+    } else {
+        /*
+         * This is the more difficult case. We must allocate new
+         * clusters for the node and zero them out.
+         */
+        int status;
+        unsigned nclsts;
+        fat_cluster_t mcl, lcl;
+        nclsts = (ROUND_UP(pos + bytes, bpc) - boundary) / bpc;
+        /* create an independent chain of nclsts clusters in all FATs */
+        status = fat_alloc_clusters(bs, dev_handle, nclsts, &mcl, &lcl);
+        if (status != EOK) {
+            /* could not allocate a chain of nclsts clusters */
+            fat_node_put(nodep);
+            ipc_answer_0(callid, status);
+            ipc_answer_0(rid, status);
+            return;
+        }
+        /* zero fill any gaps */
+        fat_fill_gap(bs, nodep, mcl, pos);
+        b = _fat_block_get(bs, dev_handle, lcl, (pos / bps) % spc,
+            flags);
+        (void) ipc_data_write_finalize(callid, b->data + pos % bps,
+            bytes);
+        b->dirty = true;        /* need to sync block */
+        block_put(b);
+        /*
+         * Append the cluster chain starting in mcl to the end of the
+         * node's cluster chain.
+         */
+        fat_append_clusters(bs, nodep, mcl);
+        nodep->size = pos + bytes;
+        nodep->dirty = true;        /* need to sync node */
+        ipc_answer_2(rid, EOK, bytes, nodep->size);
+        fat_node_put(nodep);
+        return;
+    }
+}
+void fat_truncate(ipc_callid_t rid, ipc_call_t *request)
+{
+    dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
+    fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
+    size_t size = (off_t)IPC_GET_ARG3(*request);
+    fat_node_t *nodep = (fat_node_t *)fat_node_get(dev_handle, index);
+    fat_bs_t *bs;
+    uint16_t bps;
+    uint8_t spc;
+    unsigned bpc;   /* bytes per cluster */
+    int rc;
+    if (!nodep) {
+        ipc_answer_0(rid, ENOENT);
+        return;
+    }
+    bs = block_bb_get(dev_handle);
+    bps = uint16_t_le2host(bs->bps);
+    spc = bs->spc;
+    bpc = bps * spc;
+    if (nodep->size == size) {
+        rc = EOK;
+    } else if (nodep->size < size) {
+        /*
+         * The standard says we have the freedom to grow the node.
+         * For now, we simply return an error.
+         */
+        rc = EINVAL;
+    } else if (ROUND_UP(nodep->size, bpc) == ROUND_UP(size, bpc)) {
+        /*
+         * The node will be shrunk, but no clusters will be deallocated.
+         */
+        nodep->size = size;
+        nodep->dirty = true;        /* need to sync node */
+        rc = EOK;
+    } else {
+        /*
+         * The node will be shrunk, clusters will be deallocated.
+         */
+        if (size == 0) {
+            fat_chop_clusters(bs, nodep, FAT_CLST_RES0);
+        } else {
+            fat_cluster_t lastc;
+            (void) fat_cluster_walk(bs, dev_handle, nodep->firstc,
+                &lastc, (size - 1) / bpc);
+            fat_chop_clusters(bs, nodep, lastc);
+        }
+        nodep->size = size;
+        nodep->dirty = true;        /* need to sync node */
+        rc = EOK;
+    }
+    fat_node_put(nodep);
+    ipc_answer_0(rid, rc);
+    return;
+}
+void fat_destroy(ipc_callid_t rid, ipc_call_t *request)
+{
+    dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
+    fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
+    int rc;
+    fat_node_t *nodep = fat_node_get(dev_handle, index);
+    if (!nodep) {
+        ipc_answer_0(rid, ENOENT);
+        return;
+    }
+    rc = fat_destroy_node(nodep);
+    ipc_answer_0(rid, rc);
+}
 /**
  * @}
  */

 /branches/network/uspace/srv/fs/fat/Makefile
 ,12 → 31,17
 LIBC_PREFIX = ../../../lib/libc
 LIBFS_PREFIX = ../../../lib/libfs
+LIBBLOCK_PREFIX = ../../../lib/libblock
 SOFTINT_PREFIX = ../../../lib/softint
 include $(LIBC_PREFIX)/Makefile.toolchain
-CFLAGS += -I $(LIBFS_PREFIX)
+CFLAGS += -I $(LIBFS_PREFIX) -I $(LIBBLOCK_PREFIX)
-LIBS = $(LIBC_PREFIX)/libc.a $(LIBFS_PREFIX)/libfs.a
+LIBS = \
+    $(LIBFS_PREFIX)/libfs.a \
+    $(LIBBLOCK_PREFIX)/libblock.a \
+    $(LIBC_PREFIX)/libc.a
 ## Sources
 #
 ,7 → 50,9
 SOURCES = \
     fat.c \
     fat_ops.c \
-    fat_idx.c
+    fat_idx.c \
+    fat_dentry.c \
+    fat_fat.c
 OBJECTS := $(addsuffix .o,$(basename $(SOURCES)))
 ,13 → 63,13
 -include Makefile.depend
 clean:
-    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend
+    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend $(OBJECTS)
 depend:
     $(CC) $(DEFS) $(CFLAGS) -M $(SOURCES) > Makefile.depend
 $(OUTPUT): $(OBJECTS) $(LIBS)
-    $(LD) -T $(LIBC_PREFIX)/arch/$(ARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
 disasm: $(OUTPUT).disasm

 /branches/network/uspace/srv/obio/obio.c
 ,0 → 1,158
+/*
+ * Copyright (c) 2009 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 obio
+ * @{
+ */
+/**
+ * @file    obio.c
+ * @brief   OBIO driver.
+ *
+ * OBIO is a short for on-board I/O. On UltraSPARC IIi and systems with U2P,
+ * there is a piece of the root PCI bus controller address space, which
+ * contains interrupt mapping and clear registers for all on-board devices.
+ * Although UltraSPARC IIi and U2P are different in general, these registers can
+ * be found at the same addresses.
+ */
+#include <ipc/ipc.h>
+#include <ipc/services.h>
+#include <ipc/bus.h>
+#include <ipc/ns.h>
+#include <sysinfo.h>
+#include <as.h>
+#include <ddi.h>
+#include <align.h>
+#include <bool.h>
+#include <errno.h>
+#include <async.h>
+#include <align.h>
+#include <async.h>
+#include <stdio.h>
+#include <ipc/devmap.h>
+#define NAME "obio"
+#define OBIO_SIZE   0x1898
+#define OBIO_IMR_BASE   0x200
+#define OBIO_IMR(ino)   (OBIO_IMR_BASE + ((ino) & INO_MASK))
+#define OBIO_CIR_BASE   0x300
+#define OBIO_CIR(ino)   (OBIO_CIR_BASE + ((ino) & INO_MASK))
+#define INO_MASK    0x1f
+static void *base_phys;
+static volatile uint64_t *base_virt;
+/** Handle one connection to obio.
+ *
+ * @param iid       Hash of the request that opened the connection.
+ * @param icall     Call data of the request that opened the connection.
+ */
+static void obio_connection(ipc_callid_t iid, ipc_call_t *icall)
+{
+    ipc_callid_t callid;
+    ipc_call_t call;
+    /*
+     * Answer the first IPC_M_CONNECT_ME_TO call.
+     */
+    ipc_answer_0(iid, EOK);
+    while (1) {
+        int inr;
+        callid = async_get_call(&call);
+        switch (IPC_GET_METHOD(call)) {
+        case BUS_CLEAR_INTERRUPT:
+            inr = IPC_GET_ARG1(call);
+            base_virt[OBIO_CIR(inr & INO_MASK)] = 0;
+            ipc_answer_0(callid, EOK);
+            break;
+        default:
+            ipc_answer_0(callid, EINVAL);
+            break;
+        }
+    }
+}
+/** Initialize the OBIO driver.
+ *
+ * So far, the driver heavily depends on information provided by the kernel via
+ * sysinfo. In the future, there should be a standalone OBIO driver.
+ */
+static bool obio_init(void)
+{
+    ipcarg_t phonead;
+    base_phys = (void *) sysinfo_value("obio.base.physical");
+    if (!base_phys) {
+        printf(NAME ": no OBIO registers found\n");
+        return false;
+    }
+    base_virt = as_get_mappable_page(OBIO_SIZE);
+    int flags = AS_AREA_READ | AS_AREA_WRITE;
+    int retval = physmem_map(base_phys, (void *) base_virt,
+        ALIGN_UP(OBIO_SIZE, PAGE_SIZE) >> PAGE_WIDTH, flags);
+    if (retval < 0) {
+        printf(NAME ": Error mapping OBIO registers\n");
+        return false;
+    }
+    printf(NAME ": OBIO registers with base at %p\n", base_phys);
+    async_set_client_connection(obio_connection);
+    ipc_connect_to_me(PHONE_NS, SERVICE_OBIO, 0, 0, &phonead);
+    return true;
+}
+int main(int argc, char **argv)
+{
+    printf(NAME ": HelenOS OBIO driver\n");
+    if (!obio_init())
+        return -1;
+    printf(NAME ": Accepting connections\n");
+    async_manager();
+    /* Never reached */
+    return 0;
+}
+/**
+ * @}
+ */
 Property changes:
 Added: svn:mergeinfo

 /branches/network/uspace/srv/obio/Makefile
 ,0 → 1,76
+#
+# 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.
+#
+## Setup toolchain
+#
+LIBC_PREFIX = ../../lib/libc
+SOFTINT_PREFIX = ../../lib/softint
+include $(LIBC_PREFIX)/Makefile.toolchain
+LIBS = $(LIBC_PREFIX)/libc.a
+## Sources
+#
+OUTPUT = obio
+SOURCES = \
+    obio.c
+OBJECTS := $(addsuffix .o,$(basename $(SOURCES)))
+.PHONY: all clean depend disasm
+all: $(OUTPUT) $(OUTPUT).disasm
+-include Makefile.depend
+clean:
+    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend $(OBJECTS)
+depend:
+    $(CC) $(DEFS) $(CFLAGS) -M $(SOURCES) > Makefile.depend
+$(OUTPUT): $(OBJECTS) $(LIBS)
+    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+disasm: $(OUTPUT).disasm
+$(OUTPUT).disasm: $(OUTPUT)
+    $(OBJDUMP) -d $< >$@
+%.o: %.S
+    $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@
+%.o: %.s
+    $(AS) $(AFLAGS) $< -o $@
+%.o: %.c
+    $(CC) $(DEFS) $(CFLAGS) -c $< -o $@

 /branches/network/uspace/srv/pci/Makefile
 ,6 → 31,7
 LIBC_PREFIX = ../../lib/libc
 SOFTINT_PREFIX = ../../lib/softint
 include $(LIBC_PREFIX)/Makefile.toolchain
 ,7 → 53,7
 -include Makefile.depend
 clean:
-    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend
+    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend $(OBJECTS)
     $(MAKE) -C libpci clean
 depend:
 ,7 → 61,7
 $(OUTPUT): $(OBJECTS) $(LIBS)
     $(MAKE) -C libpci
-    $(LD) -T $(LIBC_PREFIX)/arch/$(ARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
 disasm:
     $(OBJDUMP) -d $(OUTPUT) >$(OUTPUT).disasm

 /branches/network/uspace/srv/devmap/Makefile
 ,6 → 31,7
 LIBC_PREFIX = ../../lib/libc
 SOFTINT_PREFIX = ../../lib/softint
 include $(LIBC_PREFIX)/Makefile.toolchain
 CFLAGS += -I../libipc/include
 ,7 → 45,7
 SOURCES = \
     devmap.c
-CFLAGS += -D$(ARCH)
+CFLAGS += -D$(UARCH)
 OBJECTS := $(addsuffix .o,$(basename $(SOURCES)))
 ,13 → 56,13
 -include Makefile.depend
 clean:
-    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend
+    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend $(OBJECTS)
 depend:
     $(CC) $(DEFS) $(CFLAGS) -M $(SOURCES) > Makefile.depend
 $(OUTPUT): $(OBJECTS) $(LIBS)
-    $(LD) -T $(LIBC_PREFIX)/arch/$(ARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
 disasm: $(OUTPUT).disasm

 /branches/network/uspace/srv/devmap/devmap.c
 ,9 → 28,9
 /**
  * @defgroup devmap Device mapper.
- * @brief   HelenOS device mapper.
+ * @brief HelenOS device mapper.
  * @{
- */
+ */
 /** @file
  */
 ,17 → 46,24
 #include <string.h>
 #include <ipc/devmap.h>
-#define NAME "devmap"
+#define NAME  "devmap"
+/** Pending lookup structure. */
+typedef struct {
+    link_t link;
+    char *name;              /**< Device name */
+    ipc_callid_t callid;     /**< Call ID waiting for the lookup */
+} pending_req_t;
 LIST_INITIALIZE(devices_list);
 LIST_INITIALIZE(drivers_list);
+LIST_INITIALIZE(pending_req);
-/* order of locking:
- * drivers_list_futex
- * devices_list_futex
- * (devmap_driver_t *)->devices_futex
- * create_handle_futex
+/* Locking order:
+ *  drivers_list_futex
+ *  devices_list_futex
+ *  (devmap_driver_t *)->devices_futex
+ *  create_handle_futex
  **/
 static atomic_t devices_list_futex = FUTEX_INITIALIZER;
 ,27 → 70,28
 static atomic_t drivers_list_futex = FUTEX_INITIALIZER;
 static atomic_t create_handle_futex = FUTEX_INITIALIZER;
 static int devmap_create_handle(void)
 {
     static int last_handle = 0;
     int handle;
     /* TODO: allow reusing old handles after their unregistration
-        and implement some version of LRU algorithm */
+     * and implement some version of LRU algorithm
+     */
     /* FIXME: overflow */
-    futex_down(&create_handle_futex);
+    futex_down(&create_handle_futex);
     last_handle += 1;
     handle = last_handle;
-    futex_up(&create_handle_futex);
+    futex_up(&create_handle_futex);
     return handle;
 }
-/** Initialize device mapper.
+/** Initialize device mapper.
  *
  *
  */
 ,7 → 98,7
 static int devmap_init()
 {
     /* TODO: */
     return EOK;
 }
 ,108 → 107,101
  */
 static devmap_device_t *devmap_device_find_name(const char *name)
 {
-    link_t *item;
+    link_t *item = devices_list.next;
     devmap_device_t *device = NULL;
-    item = devices_list.next;
     while (item != &devices_list) {
         device = list_get_instance(item, devmap_device_t, devices);
-        if (0 == strcmp(device->name, name)) {
+        if (0 == strcmp(device->name, name))
             break;
-        }
         item = item->next;
     }
     if (item == &devices_list)
         return NULL;
     device = list_get_instance(item, devmap_device_t, devices);
     return device;
 }
 /** Find device with given handle.
+ *
  * @todo: use hash table
+ *
  */
 static devmap_device_t *devmap_device_find_handle(int handle)
 {
-    link_t *item;
+    futex_down(&devices_list_futex);
+    link_t *item = (&devices_list)->next;
     devmap_device_t *device = NULL;
-    futex_down(&devices_list_futex);
-    item = (&devices_list)->next;
     while (item != &devices_list) {
         device = list_get_instance(item, devmap_device_t, devices);
-        if (device->handle == handle) {
+        if (device->handle == handle)
             break;
-        }
         item = item->next;
     }
     if (item == &devices_list) {
         futex_up(&devices_list_futex);
         return NULL;
     }
     device = list_get_instance(item, devmap_device_t, devices);
     futex_up(&devices_list_futex);
     return device;
 }
 /**
+ *
  * Unregister device and free it. It's assumed that driver's device list is
  * already locked.
+ *
  */
 static int devmap_device_unregister_core(devmap_device_t *device)
 {
     list_remove(&(device->devices));
     list_remove(&(device->driver_devices));
-    free(device->name);
+    free(device->name);
     free(device);
     return EOK;
 }
 /**
+ *
  * Read info about new driver and add it into linked list of registered
  * drivers.
+ *
  */
 static void devmap_driver_register(devmap_driver_t **odriver)
 {
-    size_t name_size;
-    ipc_callid_t callid;
-    ipc_call_t call;
-    devmap_driver_t *driver;
-    ipc_callid_t iid;
-    ipc_call_t icall;
     *odriver = NULL;
-    iid = async_get_call(&icall);
+    ipc_call_t icall;
+    ipc_callid_t iid = async_get_call(&icall);
     if (IPC_GET_METHOD(icall) != DEVMAP_DRIVER_REGISTER) {
         ipc_answer_0(iid, EREFUSED);
         return;
-    }
-    if (NULL ==
-        (driver = (devmap_driver_t *)malloc(sizeof(devmap_driver_t)))) {
+    }
+    devmap_driver_t *driver = (devmap_driver_t *) malloc(sizeof(devmap_driver_t));
+    if (driver == NULL) {
         ipc_answer_0(iid, ENOMEM);
         return;
     }
-    /*
+    /*
      * Get driver name
      */
+    ipc_callid_t callid;
+    size_t name_size;
     if (!ipc_data_write_receive(&callid, &name_size)) {
         free(driver);
         ipc_answer_0(callid, EREFUSED);
 ,7 → 208,7
         ipc_answer_0(iid, EREFUSED);
         return;
     }
     if (name_size > DEVMAP_NAME_MAXLEN) {
         free(driver);
         ipc_answer_0(callid, EINVAL);
 ,17 → 215,18
         ipc_answer_0(iid, EREFUSED);
         return;
     }
     /*
      * Allocate buffer for device name.
      */
-    if (NULL == (driver->name = (char *)malloc(name_size + 1))) {
+    driver->name = (char *) malloc(name_size + 1);
+    if (driver->name == NULL) {
         free(driver);
         ipc_answer_0(callid, ENOMEM);
         ipc_answer_0(iid, EREFUSED);
         return;
-    }
+    }
     /*
      * Send confirmation to sender and get data into buffer.
      */
 ,22 → 236,23
         ipc_answer_0(iid, EREFUSED);
         return;
     }
     driver->name[name_size] = 0;
     /* Initialize futex for list of devices owned by this driver */
     futex_initialize(&(driver->devices_futex), 1);
-    /*
+    /*
      * Initialize list of asociated devices
      */
     list_initialize(&(driver->devices));
-    /*
+    /*
      * Create connection to the driver
      */
+    ipc_call_t call;
     callid = async_get_call(&call);
     if (IPC_M_CONNECT_TO_ME != IPC_GET_METHOD(call)) {
         ipc_answer_0(callid, ENOTSUP);
 ,73 → 261,95
         ipc_answer_0(iid, ENOTSUP);
         return;
     }
     driver->phone = IPC_GET_ARG5(call);
     ipc_answer_0(callid, EOK);
     list_initialize(&(driver->drivers));
-    futex_down(&drivers_list_futex);
+    futex_down(&drivers_list_futex);
     /* TODO:
      * check that no driver with name equal to driver->name is registered
      */
-    /*
+    /*
      * Insert new driver into list of registered drivers
      */
     list_append(&(driver->drivers), &drivers_list);
-    futex_up(&drivers_list_futex);
+    futex_up(&drivers_list_futex);
     ipc_answer_0(iid, EOK);
     *odriver = driver;
 }
-/** Unregister device driver, unregister all its devices and free driver
+/**
+ * Unregister device driver, unregister all its devices and free driver
  * structure.
+ *
  */
 static int devmap_driver_unregister(devmap_driver_t *driver)
 {
-    devmap_device_t *device;
-    if (NULL == driver)
+    if (driver == NULL)
         return EEXISTS;
-    futex_down(&drivers_list_futex);
+    futex_down(&drivers_list_futex);
     ipc_hangup(driver->phone);
     /* remove it from list of drivers */
     list_remove(&(driver->drivers));
     /* unregister all its devices */
-    futex_down(&devices_list_futex);
+    futex_down(&devices_list_futex);
     futex_down(&(driver->devices_futex));
     while (!list_empty(&(driver->devices))) {
-        device = list_get_instance(driver->devices.next,
+        devmap_device_t *device = list_get_instance(driver->devices.next,
             devmap_device_t, driver_devices);
         devmap_device_unregister_core(device);
     }
     futex_up(&(driver->devices_futex));
-    futex_up(&devices_list_futex);
-    futex_up(&drivers_list_futex);
+    futex_up(&devices_list_futex);
+    futex_up(&drivers_list_futex);
     /* free name and driver */
-    if (NULL != driver->name) {
+    if (NULL != driver->name)
         free(driver->name);
-    }
     free(driver);
     return EOK;
 }
+/** Process pending lookup requests */
+static void process_pending_lookup()
+{
+    link_t *cur;
+loop:
+    for (cur = pending_req.next; cur != &pending_req; cur = cur->next) {
+        pending_req_t *pr = list_get_instance(cur, pending_req_t, link);
+        const devmap_device_t *dev = devmap_device_find_name(pr->name);
+        if (!dev)
+            continue;
+        ipc_answer_1(pr->callid, EOK, dev->handle);
+        free(pr->name);
+        list_remove(cur);
+        free(pr);
+        goto loop;
+    }
+}
 /** Register instance of device
  *
  */
 ,29 → 356,27
 static void devmap_device_register(ipc_callid_t iid, ipc_call_t *icall,
     devmap_driver_t *driver)
 {
-    ipc_callid_t callid;
-    size_t size;
-    devmap_device_t *device;
-    if (NULL == driver) {
+    if (driver == NULL) {
         ipc_answer_0(iid, EREFUSED);
         return;
     }
     /* Create new device entry */
-    if (NULL ==
-        (device = (devmap_device_t *) malloc(sizeof(devmap_device_t)))) {
+    devmap_device_t *device = (devmap_device_t *) malloc(sizeof(devmap_device_t));
+    if (device == NULL) {
         ipc_answer_0(iid, ENOMEM);
         return;
     }
     /* Get device name */
+    ipc_callid_t callid;
+    size_t size;
     if (!ipc_data_write_receive(&callid, &size)) {
         free(device);
         ipc_answer_0(iid, EREFUSED);
         return;
     }
     if (size > DEVMAP_NAME_MAXLEN) {
         free(device);
         ipc_answer_0(callid, EINVAL);
 ,8 → 386,8
     /* +1 for terminating \0 */
     device->name = (char *) malloc(size + 1);
-    if (NULL == device->name) {
+    if (device->name == NULL) {
         free(device);
         ipc_answer_0(callid, ENOMEM);
         ipc_answer_0(iid, EREFUSED);
 ,12 → 396,12
     ipc_data_write_finalize(callid, device->name, size);
     device->name[size] = 0;
     list_initialize(&(device->devices));
     list_initialize(&(device->driver_devices));
-    futex_down(&devices_list_futex);
+    futex_down(&devices_list_futex);
     /* Check that device with such name is not already registered */
     if (NULL != devmap_device_find_name(device->name)) {
         printf(NAME ": Device '%s' already registered\n", device->name);
 ,24 → 411,26
         ipc_answer_0(iid, EEXISTS);
         return;
     }
     /* Get unique device handle */
-    device->handle = devmap_create_handle();
+    device->handle = devmap_create_handle();
     device->driver = driver;
     /* Insert device into list of all devices  */
     list_append(&device->devices, &devices_list);
     /* Insert device into list of devices that belog to one driver */
     futex_down(&device->driver->devices_futex);
     list_append(&device->driver_devices, &device->driver->devices);
-    futex_up(&device->driver->devices_futex);
-    futex_up(&devices_list_futex);
+    futex_up(&device->driver->devices_futex);
+    futex_up(&devices_list_futex);
     ipc_answer_1(iid, EOK, device->handle);
+    process_pending_lookup();
 }
 /**
 ,129 → 440,142
     devmap_driver_t *driver)
 {
     /* TODO */
     return EOK;
 }
 /** Connect client to the device.
+ *
  * Find device driver owning requested device and forward
  * the message to it.
+ *
  */
 static void devmap_forward(ipc_callid_t callid, ipc_call_t *call)
 {
-    devmap_device_t *dev;
-    int handle;
     /*
      * Get handle from request
      */
-    handle = IPC_GET_ARG2(*call);
-    dev = devmap_device_find_handle(handle);
+    int handle = IPC_GET_ARG2(*call);
+    devmap_device_t *dev = devmap_device_find_handle(handle);
     if (NULL == dev) {
         ipc_answer_0(callid, ENOENT);
         return;
-    }
+    }
     ipc_forward_fast(callid, dev->driver->phone, (ipcarg_t)(dev->handle),
         IPC_GET_ARG3(*call), 0, IPC_FF_NONE);
 }
 /** Find handle for device instance identified by name.
+ *
  * In answer will be send EOK and device handle in arg1 or a error
- * code from errno.h.
+ * code from errno.h.
+ *
  */
 static void devmap_get_handle(ipc_callid_t iid, ipc_call_t *icall)
 {
-    char *name = NULL;
-    size_t name_size;
-    const devmap_device_t *dev;
-    ipc_callid_t callid;
-    ipcarg_t retval;
-    /*
+    /*
      * Wait for incoming message with device name (but do not
      * read the name itself until the buffer is allocated).
      */
-    if (!ipc_data_write_receive(&callid, &name_size)) {
+    ipc_callid_t callid;
+    size_t size;
+    if (!ipc_data_write_receive(&callid, &size)) {
         ipc_answer_0(callid, EREFUSED);
         ipc_answer_0(iid, EREFUSED);
         return;
     }
-    if (name_size > DEVMAP_NAME_MAXLEN) {
+    if ((size < 1) || (size > DEVMAP_NAME_MAXLEN)) {
         ipc_answer_0(callid, EINVAL);
         ipc_answer_0(iid, EREFUSED);
         return;
     }
     /*
      * Allocate buffer for device name.
      */
-    if (NULL == (name = (char *)malloc(name_size))) {
+    char *name = (char *) malloc(size);
+    if (name == NULL) {
         ipc_answer_0(callid, ENOMEM);
         ipc_answer_0(iid, EREFUSED);
         return;
-    }
+    }
     /*
      * Send confirmation to sender and get data into buffer.
      */
-    if (EOK != (retval = ipc_data_write_finalize(callid, name,
-        name_size))) {
+    ipcarg_t retval = ipc_data_write_finalize(callid, name, size);
+    if (retval != EOK) {
         ipc_answer_0(iid, EREFUSED);
+        free(name);
         return;
     }
+    name[size] = '\0';
     /*
      * Find device name in linked list of known devices.
      */
-    dev = devmap_device_find_name(name);
+    const devmap_device_t *dev = devmap_device_find_name(name);
     /*
      * Device was not found.
      */
-    if (NULL == dev) {
+    if (dev == NULL) {
+        if (IPC_GET_ARG1(*icall) & IPC_FLAG_BLOCKING) {
+            /* Blocking lookup, add to pending list */
+            pending_req_t *pr = (pending_req_t *) malloc(sizeof(pending_req_t));
+            if (!pr) {
+                ipc_answer_0(iid, ENOMEM);
+                free(name);
+                return;
+            }
+            pr->name = name;
+            pr->callid = iid;
+            list_append(&pr->link, &pending_req);
+            return;
+        }
         ipc_answer_0(iid, ENOENT);
+        free(name);
         return;
     }
     ipc_answer_1(iid, EOK, dev->handle);
+    free(name);
 }
-/** Find name of device identified by id and send it to caller.
+/** Find name of device identified by id and send it to caller.
  *
  */
 static void devmap_get_name(ipc_callid_t iid, ipc_call_t *icall)
 {
-    const devmap_device_t *device;
-    size_t name_size;
-    device = devmap_device_find_handle(IPC_GET_ARG1(*icall));
+    const devmap_device_t *device = devmap_device_find_handle(IPC_GET_ARG1(*icall));
     /*
      * Device not found.
      */
-    if (NULL == device) {
+    if (device == NULL) {
         ipc_answer_0(iid, ENOENT);
         return;
-    }
+    }
     ipc_answer_0(iid, EOK);
-    name_size = strlen(device->name);
-/*  FIXME:
-    we have no channel from DEVMAP to client ->
-    sending must be initiated by client
-    int rc = ipc_data_write_send(phone, device->name, name_size);
-    if (rc != EOK) {
-        async_wait_for(req, NULL);
-        return rc;
-    }
-*/
+    size_t name_size = strlen(device->name);
+    /* FIXME:
+     * We have no channel from DEVMAP to client, therefore
+     * sending must be initiated by client.
+     *
+     * int rc = ipc_data_write_send(phone, device->name, name_size);
+     * if (rc != EOK) {
+     *     async_wait_for(req, NULL);
+     *     return rc;
+     * }
+     */
     /* TODO: send name in response */
 }
 ,31 → 584,30
  */
 static void devmap_connection_driver(ipc_callid_t iid, ipc_call_t *icall)
 {
-    ipc_callid_t callid;
-    ipc_call_t call;
-    bool cont = true;
+    /* Accept connection */
+    ipc_answer_0(iid, EOK);
     devmap_driver_t *driver = NULL;
-    ipc_answer_0(iid, EOK);
     devmap_driver_register(&driver);
     if (NULL == driver)
         return;
+    bool cont = true;
     while (cont) {
-        callid = async_get_call(&call);
-        switch (IPC_GET_METHOD(call)) {
+        ipc_call_t call;
+        ipc_callid_t callid = async_get_call(&call);
+        switch (IPC_GET_METHOD(call)) {
         case IPC_M_PHONE_HUNGUP:
             cont = false;
-            continue; /* Exit thread */
+            /* Exit thread */
+            continue;
         case DEVMAP_DRIVER_UNREGISTER:
-            if (NULL == driver) {
+            if (NULL == driver)
                 ipc_answer_0(callid, ENOENT);
-            } else {
+            else
                 ipc_answer_0(callid, EOK);
-            }
             break;
         case DEVMAP_DEVICE_REGISTER:
             /* Register one instance of device */
 ,20 → 624,18
             devmap_get_handle(callid, &call);
             break;
         default:
-            if (!(callid & IPC_CALLID_NOTIFICATION)) {
+            if (!(callid & IPC_CALLID_NOTIFICATION))
                 ipc_answer_0(callid, ENOENT);
-            }
         }
     }
     if (NULL != driver) {
-        /*
+        /*
          * Unregister the device driver and all its devices.
          */
         devmap_driver_unregister(driver);
         driver = NULL;
     }
 }
 /** Handle connection with device client.
 ,23 → 643,21
  */
 static void devmap_connection_client(ipc_callid_t iid, ipc_call_t *icall)
 {
-    ipc_callid_t callid;
-    ipc_call_t call;
+    /* Accept connection */
+    ipc_answer_0(iid, EOK);
     bool cont = true;
-    ipc_answer_0(iid, EOK); /* Accept connection */
     while (cont) {
-        callid = async_get_call(&call);
-        switch (IPC_GET_METHOD(call)) {
+        ipc_call_t call;
+        ipc_callid_t callid = async_get_call(&call);
+        switch (IPC_GET_METHOD(call)) {
         case IPC_M_PHONE_HUNGUP:
             cont = false;
-            continue; /* Exit thread */
+            /* Exit thread */
+            continue;
         case DEVMAP_DEVICE_GET_HANDLE:
-            devmap_get_handle(callid, &call);
+            devmap_get_handle(callid, &call);
             break;
         case DEVMAP_DEVICE_GET_NAME:
             /* TODO */
 ,14 → 664,13
             devmap_get_name(callid, &call);
             break;
         default:
-            if (!(callid & IPC_CALLID_NOTIFICATION)) {
+            if (!(callid & IPC_CALLID_NOTIFICATION))
                 ipc_answer_0(callid, ENOENT);
-            }
         }
     }
 }
-/** Function for handling connections to devmap
+/** Function for handling connections to devmap
  *
  */
 static void devmap_connection(ipc_callid_t iid, ipc_call_t *icall)
 ,10 → 688,9
         devmap_forward(iid, icall);
         break;
     default:
-        ipc_answer_0(iid, ENOENT); /* No such interface */
+        /* No such interface */
+        ipc_answer_0(iid, ENOENT);
     }
-    /* Cleanup */
 }
 /**
 ,8 → 700,6
 {
     printf(NAME ": HelenOS Device Mapper\n");
-    ipcarg_t phonead;
     if (devmap_init() != 0) {
         printf(NAME ": Error while initializing service\n");
         return -1;
 ,13 → 707,15
     /* Set a handler of incomming connections */
     async_set_client_connection(devmap_connection);
     /* Register device mapper at naming service */
+    ipcarg_t phonead;
     if (ipc_connect_to_me(PHONE_NS, SERVICE_DEVMAP, 0, 0, &phonead) != 0)
         return -1;
     printf(NAME ": Accepting connections\n");
     async_manager();
     /* Never reached */
     return 0;
 }

 /branches/network/uspace/srv/vfs/vfs.c
 ,11 → 28,11
 /** @addtogroup fs
  * @{
- */
+ */
 /**
- * @file    vfs.c
- * @brief   VFS service for HelenOS.
+ * @file vfs.c
+ * @brief VFS service for HelenOS.
  */
 #include <ipc/ipc.h>
 ,18 → 49,16
 #define NAME "vfs"
-#define dprintf(...)    printf(__VA_ARGS__)
 static void vfs_connection(ipc_callid_t iid, ipc_call_t *icall)
 {
-    bool keep_on_going = 1;
+    bool keep_on_going = true;
     /*
      * The connection was opened via the IPC_CONNECT_ME_TO call.
      * This call needs to be answered.
      */
     ipc_answer_0(iid, EOK);
     /*
      * Here we enter the main connection fibril loop.
      * The logic behind this loop and the protocol is that we'd like to keep
 ,18 → 70,38
      * connection later.
      */
     while (keep_on_going) {
-        ipc_callid_t callid;
         ipc_call_t call;
-        callid = async_get_call(&call);
+        ipc_callid_t callid = async_get_call(&call);
+        fs_handle_t fs_handle;
+        int phone;
         switch (IPC_GET_METHOD(call)) {
         case IPC_M_PHONE_HUNGUP:
             keep_on_going = false;
             break;
+        case IPC_M_CONNECT_ME_TO:
+            /*
+             * Connect the client file system to another one.
+             */
+            /* FIXME:
+             * Prevent ordinary clients from connecting to file
+             * system servers directly. This should be solved by
+             * applying some security mechanisms.
+             */
+            fs_handle = IPC_GET_ARG1(call);
+            phone = vfs_grab_phone(fs_handle);
+            (void) ipc_forward_fast(callid, phone, 0, 0, 0,
+                IPC_FF_NONE);
+            vfs_release_phone(phone);
+            break;
         case VFS_REGISTER:
             vfs_register(callid, &call);
-            keep_on_going = false;
+            /*
+             * Keep the connection open so that a file system can
+             * later ask us to connect it to another file system.
+             * This is necessary to support non-root mounts.
+             */
             break;
         case VFS_MOUNT:
             vfs_mount(callid, &call);
 ,22 → 138,19
             break;
         }
     }
     /* TODO: cleanup after the client */
 }
 int main(int argc, char **argv)
 {
-    ipcarg_t phonead;
     printf(NAME ": HelenOS VFS server\n");
     /*
      * Initialize the list of registered file systems.
      */
     list_initialize(&fs_head);
     /*
      * Initialize VFS node hash table.
      */
 ,7 → 158,7
         printf(NAME ": Failed to initialize VFS node hash table\n");
         return ENOMEM;
     }
     /*
      * Allocate and initialize the Path Lookup Buffer.
      */
 ,6 → 168,7
         printf(NAME ": Cannot allocate a mappable piece of address space\n");
         return ENOMEM;
     }
     if (as_area_create(plb, PLB_SIZE, AS_AREA_READ | AS_AREA_WRITE |
         AS_AREA_CACHEABLE) != plb) {
         printf(NAME ": Cannot create address space area\n");
 ,12 → 180,13
      * Set a connectio handling function/fibril.
      */
     async_set_client_connection(vfs_connection);
     /*
      * Register at the naming service.
      */
+    ipcarg_t phonead;
     ipc_connect_to_me(PHONE_NS, SERVICE_VFS, 0, 0, &phonead);
     /*
      * Start accepting connections.
      */
 ,4 → 197,4
 /**
  * @}
- */
+ */

 /branches/network/uspace/srv/vfs/vfs_ops.c
 ,11 → 28,11
 /** @addtogroup fs
  * @{
- */
+ */
 /**
- * @file    vfs_ops.c
- * @brief   Operations that VFS offers to its clients.
+ * @file vfs_ops.c
+ * @brief Operations that VFS offers to its clients.
  */
 #include "vfs.h"
 ,6 → 55,18
 /* Forward declarations of static functions. */
 static int vfs_truncate_internal(fs_handle_t, dev_handle_t, fs_index_t, size_t);
+/** Pending mount structure. */
+typedef struct {
+    link_t link;
+    char *fs_name;            /**< File system name */
+    char *mp;                 /**< Mount point */
+    ipc_callid_t callid;      /**< Call ID waiting for the mount */
+    ipc_callid_t rid;         /**< Request ID */
+    dev_handle_t dev_handle;  /**< Device handle */
+} pending_req_t;
+LIST_INITIALIZE(pending_req);
 /**
  * This rwlock prevents the race between a triplet-to-VFS-node resolution and a
  * concurrent VFS operation which modifies the file system namespace.
 ,135 → 79,43
     .dev_handle = 0
 };
-void vfs_mount(ipc_callid_t rid, ipc_call_t *request)
+static void vfs_mount_internal(ipc_callid_t rid, dev_handle_t dev_handle,
+    fs_handle_t fs_handle, char *mp)
 {
-    dev_handle_t dev_handle;
+    /* Resolve the path to the mountpoint. */
+    vfs_lookup_res_t mp_res;
     vfs_node_t *mp_node = NULL;
-    ipc_callid_t callid;
-    ipc_call_t data;
     int rc;
     int phone;
-    size_t size;
-    /*
-     * We expect the library to do the device-name to device-handle
-     * translation for us, thus the device handle will arrive as ARG1
-     * in the request.
-     */
-    dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
-    /*
-     * For now, don't make use of ARG2 and ARG3, but they can be used to
-     * carry mount options in the future.
-     */
-    /*
-     * Now, we expect the client to send us data with the name of the file
-     * system.
-     */
-    if (!ipc_data_write_receive(&callid, &size)) {
-        ipc_answer_0(callid, EINVAL);
-        ipc_answer_0(rid, EINVAL);
-        return;
-    }
-    /*
-     * Don't receive more than is necessary for storing a full file system
-     * name.
-     */
-    if (size < 1 || size > FS_NAME_MAXLEN) {
-        ipc_answer_0(callid, EINVAL);
-        ipc_answer_0(rid, EINVAL);
-        return;
-    }
-    /* Deliver the file system name. */
-    char fs_name[FS_NAME_MAXLEN + 1];
-    (void) ipc_data_write_finalize(callid, fs_name, size);
-    fs_name[size] = '\0';
-    /*
-     * Wait for IPC_M_PING so that we can return an error if we don't know
-     * fs_name.
-     */
-    callid = async_get_call(&data);
-    if (IPC_GET_METHOD(data) != IPC_M_PING) {
-        ipc_answer_0(callid, ENOTSUP);
-        ipc_answer_0(rid, ENOTSUP);
-        return;
-    }
-    /*
-     * Check if we know a file system with the same name as is in fs_name.
-     * This will also give us its file system handle.
-     */
-    fs_handle_t fs_handle = fs_name_to_handle(fs_name, true);
-    if (!fs_handle) {
-        ipc_answer_0(callid, ENOENT);
-        ipc_answer_0(rid, ENOENT);
-        return;
-    }
-    /* Acknowledge that we know fs_name. */
-    ipc_answer_0(callid, EOK);
-    /* Now, we want the client to send us the mount point. */
-    if (!ipc_data_write_receive(&callid, &size)) {
-        ipc_answer_0(callid, EINVAL);
-        ipc_answer_0(rid, EINVAL);
-        return;
-    }
-    /* Check whether size is reasonable wrt. the mount point. */
-    if (size < 1 || size > MAX_PATH_LEN) {
-        ipc_answer_0(callid, EINVAL);
-        ipc_answer_0(rid, EINVAL);
-        return;
-    }
-    /* Allocate buffer for the mount point data being received. */
-    uint8_t *buf;
-    buf = malloc(size + 1);
-    if (!buf) {
-        ipc_answer_0(callid, ENOMEM);
-        ipc_answer_0(rid, ENOMEM);
-        return;
-    }
-    /* Deliver the mount point. */
-    (void) ipc_data_write_finalize(callid, buf, size);
-    buf[size] = '\0';
-    /* Resolve the path to the mountpoint. */
-    vfs_lookup_res_t mp_res;
     futex_down(&rootfs_futex);
     if (rootfs.fs_handle) {
         /* We already have the root FS. */
         rwlock_write_lock(&namespace_rwlock);
-        if ((size == 1) && (buf[0] == '/')) {
+        if ((strlen(mp) == 1) && (mp[0] == '/')) {
             /* Trying to mount root FS over root FS */
             rwlock_write_unlock(&namespace_rwlock);
             futex_up(&rootfs_futex);
-            free(buf);
             ipc_answer_0(rid, EBUSY);
             return;
         }
-        rc = vfs_lookup_internal(buf, L_DIRECTORY, &mp_res, NULL);
+        rc = vfs_lookup_internal(mp, L_DIRECTORY, &mp_res, NULL);
         if (rc != EOK) {
             /* The lookup failed for some reason. */
             rwlock_write_unlock(&namespace_rwlock);
             futex_up(&rootfs_futex);
-            free(buf);
             ipc_answer_0(rid, rc);
             return;
         }
         mp_node = vfs_node_get(&mp_res);
         if (!mp_node) {
             rwlock_write_unlock(&namespace_rwlock);
             futex_up(&rootfs_futex);
-            free(buf);
             ipc_answer_0(rid, ENOMEM);
             return;
         }
         /*
          * Now we hold a reference to mp_node.
          * It will be dropped upon the corresponding VFS_UNMOUNT.
 ,18 → 124,17
         rwlock_write_unlock(&namespace_rwlock);
     } else {
         /* We still don't have the root file system mounted. */
-        if ((size == 1) && (buf[0] == '/')) {
+        if ((strlen(mp) == 1) && (mp[0] == '/')) {
             vfs_lookup_res_t mr_res;
             vfs_node_t *mr_node;
             ipcarg_t rindex;
             ipcarg_t rsize;
             ipcarg_t rlnkcnt;
             /*
              * For this simple, but important case,
              * we are almost done.
              */
-            free(buf);
             /* Tell the mountee that it is being mounted. */
             phone = vfs_grab_phone(fs_handle);
 ,21 → 147,22
                 ipc_answer_0(rid, rc);
                 return;
             }
             mr_res.triplet.fs_handle = fs_handle;
             mr_res.triplet.dev_handle = dev_handle;
             mr_res.triplet.index = (fs_index_t) rindex;
             mr_res.size = (size_t) rsize;
             mr_res.lnkcnt = (unsigned) rlnkcnt;
+            mr_res.type = VFS_NODE_DIRECTORY;
             rootfs.fs_handle = fs_handle;
             rootfs.dev_handle = dev_handle;
             futex_up(&rootfs_futex);
             /* Add reference to the mounted root. */
             mr_node = vfs_node_get(&mr_res);
             assert(mr_node);
             ipc_answer_0(rid, rc);
             return;
         } else {
 ,7 → 171,6
              * being mounted first.
              */
             futex_up(&rootfs_futex);
-            free(buf);
             ipc_answer_0(rid, ENOENT);
             return;
         }
 ,13 → 177,11
     }
     futex_up(&rootfs_futex);
-    free(buf);  /* The buffer is not needed anymore. */
     /*
      * At this point, we have all necessary pieces: file system and device
      * handles, and we know the mount point VFS node.
      */
     phone = vfs_grab_phone(mp_res.triplet.fs_handle);
     rc = async_req_4_0(phone, VFS_MOUNT,
         (ipcarg_t) mp_res.triplet.dev_handle,
 ,7 → 189,7
         (ipcarg_t) fs_handle,
         (ipcarg_t) dev_handle);
     vfs_release_phone(phone);
     if (rc != EOK) {
         /* Mount failed, drop reference to mp_node. */
         if (mp_node)
 ,6 → 199,170
     ipc_answer_0(rid, rc);
 }
+/** Process pending mount requests */
+void vfs_process_pending_mount()
+{
+    link_t *cur;
+loop:
+    for (cur = pending_req.next; cur != &pending_req; cur = cur->next) {
+        pending_req_t *pr = list_get_instance(cur, pending_req_t, link);
+        fs_handle_t fs_handle = fs_name_to_handle(pr->fs_name, true);
+        if (!fs_handle)
+            continue;
+        /* Acknowledge that we know fs_name. */
+        ipc_answer_0(pr->callid, EOK);
+        /* Do the mount */
+        vfs_mount_internal(pr->rid, pr->dev_handle, fs_handle, pr->mp);
+        free(pr->fs_name);
+        free(pr->mp);
+        list_remove(cur);
+        free(pr);
+        goto loop;
+    }
+}
+void vfs_mount(ipc_callid_t rid, ipc_call_t *request)
+{
+    /*
+     * We expect the library to do the device-name to device-handle
+     * translation for us, thus the device handle will arrive as ARG1
+     * in the request.
+     */
+    dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
+    /*
+     * Mount flags are passed as ARG2.
+     */
+    unsigned int flags = (unsigned int) IPC_GET_ARG2(*request);
+    /*
+     * For now, don't make use of ARG3, but it can be used to
+     * carry mount options in the future.
+     */
+    /* We want the client to send us the mount point. */
+    ipc_callid_t callid;
+    size_t size;
+    if (!ipc_data_write_receive(&callid, &size)) {
+        ipc_answer_0(callid, EINVAL);
+        ipc_answer_0(rid, EINVAL);
+        return;
+    }
+    /* Check whether size is reasonable wrt. the mount point. */
+    if ((size < 1) || (size > MAX_PATH_LEN)) {
+        ipc_answer_0(callid, EINVAL);
+        ipc_answer_0(rid, EINVAL);
+        return;
+    }
+    /* Allocate buffer for the mount point data being received. */
+    char *mp = malloc(size + 1);
+    if (!mp) {
+        ipc_answer_0(callid, ENOMEM);
+        ipc_answer_0(rid, ENOMEM);
+        return;
+    }
+    /* Deliver the mount point. */
+    ipcarg_t retval = ipc_data_write_finalize(callid, mp, size);
+    if (retval != EOK) {
+        ipc_answer_0(rid, EREFUSED);
+        free(mp);
+        return;
+    }
+    mp[size] = '\0';
+    /*
+     * Now, we expect the client to send us data with the name of the file
+     * system.
+     */
+    if (!ipc_data_write_receive(&callid, &size)) {
+        ipc_answer_0(callid, EINVAL);
+        ipc_answer_0(rid, EINVAL);
+        free(mp);
+        return;
+    }
+    /*
+     * Don't receive more than is necessary for storing a full file system
+     * name.
+     */
+    if ((size < 1) || (size > FS_NAME_MAXLEN)) {
+        ipc_answer_0(callid, EINVAL);
+        ipc_answer_0(rid, EINVAL);
+        free(mp);
+        return;
+    }
+    /*
+     * Allocate buffer for file system name.
+     */
+    char *fs_name = (char *) malloc(size + 1);
+    if (fs_name == NULL) {
+        ipc_answer_0(callid, ENOMEM);
+        ipc_answer_0(rid, EREFUSED);
+        free(mp);
+        return;
+    }
+    /* Deliver the file system name. */
+    retval = ipc_data_write_finalize(callid, fs_name, size);
+    if (retval != EOK) {
+        ipc_answer_0(rid, EREFUSED);
+        free(mp);
+        free(fs_name);
+        return;
+    }
+    fs_name[size] = '\0';
+    /*
+     * Check if we know a file system with the same name as is in fs_name.
+     * This will also give us its file system handle.
+     */
+    fs_handle_t fs_handle = fs_name_to_handle(fs_name, true);
+    if (!fs_handle) {
+        if (flags & IPC_FLAG_BLOCKING) {
+            /* Blocking mount, add to pending list */
+            pending_req_t *pr = (pending_req_t *) malloc(sizeof(pending_req_t));
+            if (!pr) {
+                ipc_answer_0(callid, ENOMEM);
+                ipc_answer_0(rid, ENOMEM);
+                free(mp);
+                free(fs_name);
+                return;
+            }
+            pr->fs_name = fs_name;
+            pr->mp = mp;
+            pr->callid = callid;
+            pr->rid = rid;
+            pr->dev_handle = dev_handle;
+            list_append(&pr->link, &pending_req);
+            return;
+        }
+        ipc_answer_0(callid, ENOENT);
+        ipc_answer_0(rid, ENOENT);
+        free(mp);
+        free(fs_name);
+        return;
+    }
+    /* Acknowledge that we know fs_name. */
+    ipc_answer_0(callid, EOK);
+    /* Do the mount */
+    vfs_mount_internal(rid, dev_handle, fs_handle, mp);
+    free(mp);
+    free(fs_name);
+}
 void vfs_open(ipc_callid_t rid, ipc_call_t *request)
 {
     if (!vfs_files_init()) {
 ,6 → 383,16
     int mode = IPC_GET_ARG3(*request);
     size_t len;
+    /*
+     * Make sure that we are called with exactly one of L_FILE and
+     * L_DIRECTORY.
+     */
+    if ((lflag & (L_FILE | L_DIRECTORY)) == 0 ||
+        (lflag & (L_FILE | L_DIRECTORY)) == (L_FILE | L_DIRECTORY)) {
+        ipc_answer_0(rid, EINVAL);
+        return;
+    }
     if (oflag & O_CREAT)
         lflag |= L_CREATE;
     if (oflag & O_EXCL)
 ,7 → 547,7
      * the same open file at a time.
      */
     futex_down(&file->lock);
     /*
      * Lock the file's node so that no other client can read/write to it at
      * the same time.
 ,6 → 556,15
         rwlock_read_lock(&file->node->contents_rwlock);
     else
         rwlock_write_lock(&file->node->contents_rwlock);
+    if (file->node->type == VFS_NODE_DIRECTORY) {
+        /*
+         * Make sure that no one is modifying the namespace
+         * while we are in readdir().
+         */
+        assert(read);
+        rwlock_read_lock(&namespace_rwlock);
+    }
     int fs_phone = vfs_grab_phone(file->node->fs_handle);
 ,6 → 590,9
     ipcarg_t rc;
     async_wait_for(msg, &rc);
     size_t bytes = IPC_GET_ARG1(answer);
+    if (file->node->type == VFS_NODE_DIRECTORY)
+        rwlock_read_unlock(&namespace_rwlock);
     /* Unlock the VFS node. */
     if (read)

 /branches/network/uspace/srv/vfs/vfs_register.c
 ,10 → 28,10
 /** @addtogroup fs
  * @{
- */
+ */
 /**
- * @file    vfs_register.c
+ * @file vfs_register.c
  * @brief
  */
 ,30 → 98,6
         return false;
     }
-    /*
-     * Check if the FS implements mandatory VFS operations.
-     */
-    if (info->ops[IPC_METHOD_TO_VFS_OP(VFS_LOOKUP)] != VFS_OP_DEFINED) {
-        dprintf("Operation VFS_LOOKUP not defined by the client.\n");
-        return false;
-    }
-    if (info->ops[IPC_METHOD_TO_VFS_OP(VFS_READ)] != VFS_OP_DEFINED) {
-        dprintf("Operation VFS_READ not defined by the client.\n");
-        return false;
-    }
-    /*
-     * Check if each operation is either not defined, defined or default.
-     */
-    for (i = VFS_FIRST; i < VFS_LAST_CLNT; i++) {
-        if ((info->ops[IPC_METHOD_TO_VFS_OP(i)] != VFS_OP_NULL) &&
-            (info->ops[IPC_METHOD_TO_VFS_OP(i)] != VFS_OP_DEFAULT) &&
-            (info->ops[IPC_METHOD_TO_VFS_OP(i)] != VFS_OP_DEFINED)) {
-            dprintf("Operation info not understood.\n");
-            return false;
-        }
-    }
     return true;
 }
 ,6 → 278,11
     dprintf("\"%.*s\" filesystem successfully registered, handle=%d.\n",
         FS_NAME_MAXLEN, fs_info->vfs_info.name, fs_info->fs_handle);
+    /* Process pending mount requests possibly waiting
+     * for this filesystem implementation.
+     */
+    vfs_process_pending_mount();
 }
 /** For a given file system handle, implement policy for allocating a phone.

 /branches/network/uspace/srv/vfs/vfs.h
 ,8 → 47,6
 #define VFS_FIRST   IPC_FIRST_USER_METHOD
-#define IPC_METHOD_TO_VFS_OP(m) ((m) - VFS_FIRST)
 /* Basic types. */
 typedef int16_t fs_handle_t;
 typedef int16_t dev_handle_t;
 ,32 → 79,16
     VFS_LAST_SRV,   /* keep this the last member of this enum */
 } vfs_request_srv_t;
-/**
- * An instance of this structure is associated with a particular FS operation.
- * It tells VFS if the FS supports the operation or maybe if a default one
- * should be used.
- */
-typedef enum {
-    VFS_OP_NULL = 0,
-    VFS_OP_DEFAULT,
-    VFS_OP_DEFINED
-} vfs_op_t;
 #define FS_NAME_MAXLEN  20
 /**
  * A structure like this is passed to VFS by each individual FS upon its
  * registration. It assosiates a human-readable identifier with each
- * registered FS. More importantly, through this structure, the FS announces
- * what operations it supports.
+ * registered FS.
  */
 typedef struct {
     /** Unique identifier of the fs. */
     char name[FS_NAME_MAXLEN + 1];
-    /** Operations. */
-    vfs_op_t ops[VFS_LAST_CLNT - VFS_FIRST];
 } vfs_info_t;
 /**
 ,8 → 172,15
  */
 #define L_PARENT    64
+typedef enum vfs_node_type {
+    VFS_NODE_UNKNOWN,
+    VFS_NODE_FILE,
+    VFS_NODE_DIRECTORY,
+} vfs_node_type_t;
 typedef struct {
     vfs_triplet_t triplet;
+    vfs_node_type_t type;
     size_t size;
     unsigned lnkcnt;
 } vfs_lookup_res_t;
 ,6 → 202,9
     unsigned lnkcnt;
     link_t nh_link;     /**< Node hash-table link. */
+    vfs_node_type_t type;   /**< Partial info about the node type. */
     size_t size;        /**< Cached size if the node is a file. */
     /**
 ,6 → 282,7
 extern void vfs_node_addref(vfs_node_t *);
 extern void vfs_node_delref(vfs_node_t *);
+extern void vfs_process_pending_mount(void);
 extern void vfs_register(ipc_callid_t, ipc_call_t *);
 extern void vfs_mount(ipc_callid_t, ipc_call_t *);
 extern void vfs_open(ipc_callid_t, ipc_call_t *);

 /branches/network/uspace/srv/vfs/vfs_node.c
 ,15 → 175,22
         node->index = result->triplet.index;
         node->size = result->size;
         node->lnkcnt = result->lnkcnt;
+        node->type = result->type;
         link_initialize(&node->nh_link);
         rwlock_initialize(&node->contents_rwlock);
         hash_table_insert(&nodes, key, &node->nh_link);
     } else {
         node = hash_table_get_instance(tmp, vfs_node_t, nh_link);
+        if (node->type == VFS_NODE_UNKNOWN &&
+            result->type != VFS_NODE_UNKNOWN) {
+            /* Upgrade the node type. */
+            node->type = result->type;
+        }
     }
     assert(node->size == result->size);
     assert(node->lnkcnt == result->lnkcnt);
+    assert(node->type == result->type || result->type == VFS_NODE_UNKNOWN);
     _vfs_node_addref(node);
     futex_up(&nodes_futex);

 /branches/network/uspace/srv/vfs/vfs_lookup.c
 ,6 → 182,12
         result->triplet.index = (fs_index_t) IPC_GET_ARG3(answer);
         result->size = (size_t) IPC_GET_ARG4(answer);
         result->lnkcnt = (unsigned) IPC_GET_ARG5(answer);
+        if (lflag & L_FILE)
+            result->type = VFS_NODE_FILE;
+        else if (lflag & L_DIRECTORY)
+            result->type = VFS_NODE_DIRECTORY;
+        else
+            result->type = VFS_NODE_UNKNOWN;
     }
     return rc;

 /branches/network/uspace/srv/vfs/Makefile
 ,6 → 32,7
 LIBC_PREFIX = ../../lib/libc
 SOFTINT_PREFIX = ../../lib/softint
 include $(LIBC_PREFIX)/Makefile.toolchain
 LIBS = $(LIBC_PREFIX)/libc.a
 ,13 → 58,13
 -include Makefile.depend
 clean:
-    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend
+    -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend $(OBJECTS)
 depend:
     $(CC) $(DEFS) $(CFLAGS) -M $(SOURCES) > Makefile.depend
 $(OUTPUT): $(OBJECTS) $(LIBS)
-    $(LD) -T $(LIBC_PREFIX)/arch/$(ARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
+    $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map
 disasm: $(OUTPUT).disasm

Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 4077 → Rev 4153