WebSVN – HelenOS – Path Comparison – / – /branches/dd/kernel/ Rev 4419 and /branches/dd/kernel/ Rev 4420

Ignore whitespace Rev 4419 → Rev 4420

 /branches/dd/kernel/genarch/include/kbrd/kbrd.h
 ,9 → 37,23
 #define KERN_KBD_H_
 #include <console/chardev.h>
+#include <proc/thread.h>
+#include <synch/spinlock.h>
-extern void kbrd_init(indev_t *devin);
+typedef struct {
+    thread_t *thread;
+    indev_t *sink;
+    indev_t raw;
+    SPINLOCK_DECLARE(keylock);        /**< keylock protects keyflags and lockflags. */
+    volatile unsigned int keyflags;   /**< Tracking of multiple keypresses. */
+    volatile unsigned int lockflags;  /**< Tracking of multiple keys lockings. */
+} kbrd_instance_t;
+extern kbrd_instance_t *kbrd_init(void);
+extern indev_t *kbrd_wire(kbrd_instance_t *, indev_t *);
 #endif
 /** @}

 /branches/dd/kernel/genarch/include/drivers/ns16550/ns16550.h
 ,12 → 62,13
 /** Structure representing the ns16550 device. */
 typedef struct {
+    irq_t irq;
     ns16550_t *ns16550;
-    irq_t irq;
-    indev_t kbrdin;
+    indev_t *kbrdin;
 } ns16550_instance_t;
-extern indev_t *ns16550_init(ns16550_t *, inr_t, cir_t, void *);
+extern ns16550_instance_t *ns16550_init(ns16550_t *, inr_t, cir_t, void *);
+extern void ns16550_wire(ns16550_instance_t *, indev_t *);
 #endif

 /branches/dd/kernel/genarch/include/drivers/dsrln/dsrlnin.h
 ,10 → 49,11
 typedef struct {
     irq_t irq;
     dsrlnin_t *dsrlnin;
-    indev_t kbrdin;
+    indev_t *srlnin;
 } dsrlnin_instance_t;
-extern indev_t *dsrlnin_init(dsrlnin_t *, inr_t);
+extern dsrlnin_instance_t *dsrlnin_init(dsrlnin_t *, inr_t);
+extern void dsrlnin_wire(dsrlnin_instance_t *, indev_t *);
 #endif

 /branches/dd/kernel/genarch/include/drivers/i8042/i8042.h
 ,10 → 49,11
 typedef struct {
     irq_t irq;
     i8042_t *i8042;
-    indev_t kbrdin;
+    indev_t *kbrdin;
 } i8042_instance_t;
-extern indev_t *i8042_init(i8042_t *, inr_t);
+extern i8042_instance_t *i8042_init(i8042_t *, inr_t);
+extern void i8042_wire(i8042_instance_t *, indev_t *);
 extern void i8042_cpu_reset(i8042_t *);
 #endif

 /branches/dd/kernel/genarch/include/drivers/z8530/z8530.h
 ,10 → 116,11
 typedef struct {
     irq_t irq;
     z8530_t *z8530;
-    indev_t kbrdin;
+    indev_t *kbrdin;
 } z8530_instance_t;
-extern indev_t *z8530_init(z8530_t *, inr_t, cir_t, void *);
+extern z8530_instance_t *z8530_init(z8530_t *, inr_t, cir_t, void *);
+extern void z8530_wire(z8530_instance_t *, indev_t *);
 #endif

 /branches/dd/kernel/genarch/include/drivers/via-cuda/cuda.h
 ,0 → 1,57
+/*
+ * 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 genarch
+ * @{
+ */
+/** @file
+ */
+#ifndef KERN_CUDA_H_
+#define KERN_CUDA_H_
+#include <ddi/irq.h>
+#include <arch/types.h>
+#include <console/chardev.h>
+typedef struct {
+} cuda_t;
+typedef struct {
+    irq_t irq;
+    cuda_t *cuda;
+    indev_t *kbrdin;
+} cuda_instance_t;
+extern cuda_instance_t *cuda_init(cuda_t *, inr_t, cir_t, void *);
+extern void cuda_wire(cuda_instance_t *, indev_t *);
+#endif
+/** @}
+ */
 Property changes:
 Added: svn:mergeinfo

 /branches/dd/kernel/genarch/include/srln/srln.h
 ,9 → 37,18
 #define KERN_SRLN_H_
 #include <console/chardev.h>
+#include <proc/thread.h>
-extern void srln_init(indev_t *devin);
+typedef struct {
+    thread_t *thread;
+    indev_t *sink;
+    indev_t raw;
+} srln_instance_t;
+extern srln_instance_t *srln_init(void);
+extern indev_t *srln_wire(srln_instance_t *, indev_t *);
 #endif
 /** @}

 /branches/dd/kernel/genarch/Makefile.inc
 ,6 → 93,11
         genarch/src/drivers/z8530/z8530.c
 endif
+ifeq ($(CONFIG_VIA_CUDA),y)
+    GENARCH_SOURCES += \
+        genarch/src/drivers/via-cuda/cuda.c
+endif
 ifeq ($(CONFIG_PC_KBD),y)
     GENARCH_SOURCES += \
         genarch/src/kbrd/kbrd.c \

 /branches/dd/kernel/genarch/src/kbrd/kbrd.c
 ,39 → 59,35
 #define PRESSED_CAPSLOCK  (1 << 1)
 #define LOCKED_CAPSLOCK   (1 << 0)
-static indev_t kbrdout;
-indev_operations_t kbrdout_ops = {
+static indev_operations_t kbrd_raw_ops = {
     .poll = NULL
 };
-SPINLOCK_INITIALIZE(keylock);   /**< keylock protects keyflags and lockflags. */
-static volatile int keyflags;   /**< Tracking of multiple keypresses. */
-static volatile int lockflags;  /**< Tracking of multiple keys lockings. */
 /** Process release of key.
  *
  * @param sc Scancode of the key being released.
  */
-static void key_released(wchar_t sc)
+static void key_released(kbrd_instance_t *instance, wchar_t sc)
 {
-    spinlock_lock(&keylock);
+    spinlock_lock(&instance->keylock);
     switch (sc) {
     case SC_LSHIFT:
     case SC_RSHIFT:
-        keyflags &= ~PRESSED_SHIFT;
+        instance->keyflags &= ~PRESSED_SHIFT;
         break;
     case SC_CAPSLOCK:
-        keyflags &= ~PRESSED_CAPSLOCK;
-        if (lockflags & LOCKED_CAPSLOCK)
-            lockflags &= ~LOCKED_CAPSLOCK;
+        instance->keyflags &= ~PRESSED_CAPSLOCK;
+        if (instance->lockflags & LOCKED_CAPSLOCK)
+            instance->lockflags &= ~LOCKED_CAPSLOCK;
         else
-            lockflags |= LOCKED_CAPSLOCK;
+            instance->lockflags |= LOCKED_CAPSLOCK;
         break;
     default:
         break;
     }
-    spinlock_unlock(&keylock);
+    spinlock_unlock(&instance->keylock);
 }
 /** Process keypress.
 ,69 → 94,94
  *
  * @param sc Scancode of the key being pressed.
  */
-static void key_pressed(wchar_t sc)
+static void key_pressed(kbrd_instance_t *instance, wchar_t sc)
 {
     bool letter;
     bool shift;
     bool capslock;
-    spinlock_lock(&keylock);
+    spinlock_lock(&instance->keylock);
     switch (sc) {
     case SC_LSHIFT:
     case SC_RSHIFT:
-        keyflags |= PRESSED_SHIFT;
+        instance->keyflags |= PRESSED_SHIFT;
         break;
     case SC_CAPSLOCK:
-        keyflags |= PRESSED_CAPSLOCK;
+        instance->keyflags |= PRESSED_CAPSLOCK;
         break;
     case SC_SCAN_ESCAPE:
         break;
     default:
         letter = islower(sc_primary_map[sc]);
-        shift = keyflags & PRESSED_SHIFT;
-        capslock = (keyflags & PRESSED_CAPSLOCK) ||
-            (lockflags & LOCKED_CAPSLOCK);
+        shift = instance->keyflags & PRESSED_SHIFT;
+        capslock = (instance->keyflags & PRESSED_CAPSLOCK) ||
+            (instance->lockflags & LOCKED_CAPSLOCK);
         if ((letter) && (capslock))
             shift = !shift;
         if (shift)
-            indev_push_character(stdin, sc_secondary_map[sc]);
+            indev_push_character(instance->sink, sc_secondary_map[sc]);
         else
-            indev_push_character(stdin, sc_primary_map[sc]);
+            indev_push_character(instance->sink, sc_primary_map[sc]);
         break;
     }
-    spinlock_unlock(&keylock);
+    spinlock_unlock(&instance->keylock);
 }
 static void kkbrd(void *arg)
 {
-    indev_t *in = (indev_t *) arg;
+    kbrd_instance_t *instance = (kbrd_instance_t *) arg;
     while (true) {
-        wchar_t sc = _getc(in);
+        wchar_t sc = indev_pop_character(&instance->raw);
         if (sc == IGNORE_CODE)
             continue;
         if (sc & KEY_RELEASE)
-            key_released((sc ^ KEY_RELEASE) & 0x7f);
+            key_released(instance, (sc ^ KEY_RELEASE) & 0x7f);
         else
-            key_pressed(sc & 0x7f);
+            key_pressed(instance, sc & 0x7f);
     }
 }
-void kbrd_init(indev_t *devin)
+kbrd_instance_t *kbrd_init(void)
 {
-    indev_initialize("kbrd", &kbrdout, &kbrdout_ops);
-    thread_t *thread
-        = thread_create(kkbrd, devin, TASK, 0, "kkbrd", false);
+    kbrd_instance_t *instance
+        = malloc(sizeof(kbrd_instance_t), FRAME_ATOMIC);
+    if (instance) {
+        instance->thread
+            = thread_create(kkbrd, (void *) instance, TASK, 0, "kkbrd", false);
+        if (!instance->thread) {
+            free(instance);
+            return NULL;
+        }
+        instance->sink = NULL;
+        indev_initialize("kbrd", &instance->raw, &kbrd_raw_ops);
+        spinlock_initialize(&instance->keylock, "instance_keylock");
+        instance->keyflags = 0;
+        instance->lockflags = 0;
+    }
-    if (thread) {
-        stdin = &kbrdout;
-        thread_ready(thread);
-    }
+    return instance;
 }
+indev_t *kbrd_wire(kbrd_instance_t *instance, indev_t *sink)
+{
+    ASSERT(instance);
+    ASSERT(sink);
+    instance->sink = sink;
+    thread_ready(instance->thread);
+    return &instance->raw;
+}
 /** @}
  */

 /branches/dd/kernel/genarch/src/drivers/ns16550/ns16550.c
 ,10 → 43,6
 #define LSR_DATA_READY  0x01
-static indev_operations_t kbrdin_ops = {
-    .poll = NULL
-};
 static irq_ownership_t ns16550_claim(irq_t *irq)
 {
     ns16550_instance_t *instance = irq->instance;
 ,11 → 60,18
     ns16550_t *dev = instance->ns16550;
     if (pio_read_8(&dev->lsr) & LSR_DATA_READY) {
-        uint8_t x = pio_read_8(&dev->rbr);
-        indev_push_character(&instance->kbrdin, x);
+        uint8_t data = pio_read_8(&dev->rbr);
+        indev_push_character(instance->kbrdin, data);
     }
 }
+/**< Clear input buffer. */
+static void ns16550_clear_buffer(ns16550_t *dev)
+{
+    while ((pio_read_8(&dev->lsr) & LSR_DATA_READY))
+        (void) pio_read_8(&dev->rbr);
+}
 /** Initialize ns16550.
  *
  * @param dev      Addrress of the beginning of the device in I/O space.
 ,38 → 80,43
  * @param cir      Clear interrupt function.
  * @param cir_arg  First argument to cir.
  *
- * @return Keyboard device pointer or NULL on failure.
+ * @return Keyboard instance or NULL on failure.
  *
  */
-indev_t *ns16550_init(ns16550_t *dev, inr_t inr, cir_t cir, void *cir_arg)
+ns16550_instance_t *ns16550_init(ns16550_t *dev, inr_t inr, cir_t cir, void *cir_arg)
 {
     ns16550_instance_t *instance
         = malloc(sizeof(ns16550_instance_t), FRAME_ATOMIC);
-    if (!instance)
-        return NULL;
+    if (instance) {
+        instance->ns16550 = dev;
+        instance->kbrdin = NULL;
+        irq_initialize(&instance->irq);
+        instance->irq.devno = device_assign_devno();
+        instance->irq.inr = inr;
+        instance->irq.claim = ns16550_claim;
+        instance->irq.handler = ns16550_irq_handler;
+        instance->irq.instance = instance;
+        instance->irq.cir = cir;
+        instance->irq.cir_arg = cir_arg;
+    }
-    indev_initialize("ns16550", &instance->kbrdin, &kbrdin_ops);
+    return instance;
+}
+void ns16550_wire(ns16550_instance_t *instance, indev_t *kbrdin)
+{
+    ASSERT(instance);
+    ASSERT(kbrdin);
-    instance->ns16550 = dev;
-    irq_initialize(&instance->irq);
-    instance->irq.devno = device_assign_devno();
-    instance->irq.inr = inr;
-    instance->irq.claim = ns16550_claim;
-    instance->irq.handler = ns16550_irq_handler;
-    instance->irq.instance = instance;
-    instance->irq.cir = cir;
-    instance->irq.cir_arg = cir_arg;
+    instance->kbrdin = kbrdin;
     irq_register(&instance->irq);
-    while ((pio_read_8(&dev->lsr) & LSR_DATA_READY))
-        (void) pio_read_8(&dev->rbr);
+    ns16550_clear_buffer(instance->ns16550);
     /* Enable interrupts */
-    pio_write_8(&dev->ier, IER_ERBFI);
-    pio_write_8(&dev->mcr, MCR_OUT2);
-    return &instance->kbrdin;
+    pio_write_8(&instance->ns16550->ier, IER_ERBFI);
+    pio_write_8(&instance->ns16550->mcr, MCR_OUT2);
 }
 /** @}

 /branches/dd/kernel/genarch/src/drivers/dsrln/dsrlnin.c
 ,10 → 40,6
 #include <arch/asm.h>
 #include <ddi/device.h>
-static indev_operations_t kbrdin_ops = {
-    .poll = NULL
-};
 static irq_ownership_t dsrlnin_claim(irq_t *irq)
 {
     return IRQ_ACCEPT;
 ,29 → 50,35
     dsrlnin_instance_t *instance = irq->instance;
     dsrlnin_t *dev = instance->dsrlnin;
-    indev_push_character(&instance->kbrdin, pio_read_8(&dev->data));
+    indev_push_character(instance->srlnin, pio_read_8(&dev->data));
 }
-indev_t *dsrlnin_init(dsrlnin_t *dev, inr_t inr)
+dsrlnin_instance_t *dsrlnin_init(dsrlnin_t *dev, inr_t inr)
 {
     dsrlnin_instance_t *instance
         = malloc(sizeof(dsrlnin_instance_t), FRAME_ATOMIC);
-    if (!instance)
-        return NULL;
+    if (instance) {
+        instance->dsrlnin = dev;
+        instance->srlnin = NULL;
+        irq_initialize(&instance->irq);
+        instance->irq.devno = device_assign_devno();
+        instance->irq.inr = inr;
+        instance->irq.claim = dsrlnin_claim;
+        instance->irq.handler = dsrlnin_irq_handler;
+        instance->irq.instance = instance;
+    }
-    indev_initialize("dsrlnin", &instance->kbrdin, &kbrdin_ops);
+    return instance;
+}
+void dsrlnin_wire(dsrlnin_instance_t *instance, indev_t *srlnin)
+{
+    ASSERT(instance);
+    ASSERT(srlnin);
-    instance->dsrlnin = dev;
-    irq_initialize(&instance->irq);
-    instance->irq.devno = device_assign_devno();
-    instance->irq.inr = inr;
-    instance->irq.claim = dsrlnin_claim;
-    instance->irq.handler = dsrlnin_irq_handler;
-    instance->irq.instance = instance;
+    instance->srlnin = srlnin;
     irq_register(&instance->irq);
-    return &instance->kbrdin;
 }
 /** @}

 /branches/dd/kernel/genarch/src/drivers/i8042/i8042.c
 ,10 → 44,6
 #include <mm/slab.h>
 #include <ddi/device.h>
-static indev_operations_t kbrdin_ops = {
-    .poll = NULL
-};
 #define i8042_SET_COMMAND  0x60
 #define i8042_COMMAND      0x69
 #define i8042_CPU_RESET    0xfe
 ,35 → 70,46
     if (((status = pio_read_8(&dev->status)) & i8042_BUFFER_FULL_MASK)) {
         uint8_t data = pio_read_8(&dev->data);
-        indev_push_character(&instance->kbrdin, data);
+        indev_push_character(instance->kbrdin, data);
     }
 }
+/**< Clear input buffer. */
+static void i8042_clear_buffer(i8042_t *dev)
+{
+    while (pio_read_8(&dev->status) & i8042_BUFFER_FULL_MASK)
+        (void) pio_read_8(&dev->data);
+}
 /** Initialize i8042. */
-indev_t *i8042_init(i8042_t *dev, inr_t inr)
+i8042_instance_t *i8042_init(i8042_t *dev, inr_t inr)
 {
     i8042_instance_t *instance
         = malloc(sizeof(i8042_instance_t), FRAME_ATOMIC);
-    if (!instance)
-        return NULL;
+    if (instance) {
+        instance->i8042 = dev;
+        instance->kbrdin = NULL;
+        irq_initialize(&instance->irq);
+        instance->irq.devno = device_assign_devno();
+        instance->irq.inr = inr;
+        instance->irq.claim = i8042_claim;
+        instance->irq.handler = i8042_irq_handler;
+        instance->irq.instance = instance;
+    }
-    indev_initialize("i8042", &instance->kbrdin, &kbrdin_ops);
+    return instance;
+}
+void i8042_wire(i8042_instance_t *instance, indev_t *kbrdin)
+{
+    ASSERT(instance);
+    ASSERT(kbrdin);
-    instance->i8042 = dev;
-    irq_initialize(&instance->irq);
-    instance->irq.devno = device_assign_devno();
-    instance->irq.inr = inr;
-    instance->irq.claim = i8042_claim;
-    instance->irq.handler = i8042_irq_handler;
-    instance->irq.instance = instance;
+    instance->kbrdin = kbrdin;
     irq_register(&instance->irq);
-    /* Clear input buffer */
-    while (pio_read_8(&dev->status) & i8042_BUFFER_FULL_MASK)
-        (void) pio_read_8(&dev->data);
-    return &instance->kbrdin;
+    i8042_clear_buffer(instance->i8042);
 }
 /* Reset CPU by pulsing pin 0 */
 ,9 → 117,7
 {
     interrupts_disable();
-    /* Clear input buffer */
-    while (pio_read_8(&dev->status) & i8042_BUFFER_FULL_MASK)
-        (void) pio_read_8(&dev->data);
+    i8042_clear_buffer(dev);
     /* Reset CPU */
     pio_write_8(&dev->status, i8042_CPU_RESET);

 /branches/dd/kernel/genarch/src/drivers/z8530/z8530.c
 ,10 → 41,6
 #include <mm/slab.h>
 #include <ddi/device.h>
-static indev_operations_t kbrdin_ops = {
-    .poll = NULL
-};
 static inline void z8530_write(ioport8_t *ctl, uint8_t reg, uint8_t val)
 {
     /*
 ,51 → 78,58
     z8530_t *dev = instance->z8530;
     if (z8530_read(&dev->ctl_a, RR0) & RR0_RCA) {
-        uint8_t x = z8530_read(&dev->ctl_a, RR8);
-        indev_push_character(&instance->kbrdin, x);
+        uint8_t data = z8530_read(&dev->ctl_a, RR8);
+        indev_push_character(instance->kbrdin, data);
     }
 }
 /** Initialize z8530. */
-indev_t *z8530_init(z8530_t *dev, inr_t inr, cir_t cir, void *cir_arg)
+z8530_instance_t *z8530_init(z8530_t *dev, inr_t inr, cir_t cir, void *cir_arg)
 {
     z8530_instance_t *instance
         = malloc(sizeof(z8530_instance_t), FRAME_ATOMIC);
-    if (!instance)
-        return false;
+    if (instance) {
+        instance->z8530 = dev;
+        instance->kbrdin = NULL;
+        irq_initialize(&instance->irq);
+        instance->irq.devno = device_assign_devno();
+        instance->irq.inr = inr;
+        instance->irq.claim = z8530_claim;
+        instance->irq.handler = z8530_irq_handler;
+        instance->irq.instance = instance;
+        instance->irq.cir = cir;
+        instance->irq.cir_arg = cir_arg;
+    }
-    indev_initialize("z8530", &instance->kbrdin, &kbrdin_ops);
+    return instance;
+}
+void z8530_wire(z8530_instance_t *instance, indev_t *kbrdin)
+{
+    ASSERT(instance);
+    ASSERT(kbrdin);
-    instance->z8530 = dev;
+    instance->kbrdin = kbrdin;
-    irq_initialize(&instance->irq);
-    instance->irq.devno = device_assign_devno();
-    instance->irq.inr = inr;
-    instance->irq.claim = z8530_claim;
-    instance->irq.handler = z8530_irq_handler;
-    instance->irq.instance = instance;
-    instance->irq.cir = cir;
-    instance->irq.cir_arg = cir_arg;
     irq_register(&instance->irq);
-    (void) z8530_read(&dev->ctl_a, RR8);
+    (void) z8530_read(&instance->z8530->ctl_a, RR8);
     /*
      * Clear any pending TX interrupts or we never manage
      * to set FHC UART interrupt state to idle.
      */
-    z8530_write(&dev->ctl_a, WR0, WR0_TX_IP_RST);
+    z8530_write(&instance->z8530->ctl_a, WR0, WR0_TX_IP_RST);
     /* interrupt on all characters */
-    z8530_write(&dev->ctl_a, WR1, WR1_IARCSC);
+    z8530_write(&instance->z8530->ctl_a, WR1, WR1_IARCSC);
     /* 8 bits per character and enable receiver */
-    z8530_write(&dev->ctl_a, WR3, WR3_RX8BITSCH | WR3_RX_ENABLE);
+    z8530_write(&instance->z8530->ctl_a, WR3, WR3_RX8BITSCH | WR3_RX_ENABLE);
     /* Master Interrupt Enable. */
-    z8530_write(&dev->ctl_a, WR9, WR9_MIE);
-    return &instance->kbrdin;
+    z8530_write(&instance->z8530->ctl_a, WR9, WR9_MIE);
 }
 /** @}

 /branches/dd/kernel/genarch/src/drivers/via-cuda/cuda.c
 ,0 → 1,78
+/*
+ * Copyright (c) 2006 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup genarch
+ * @{
+ */
+/** @file
+ */
+#include <genarch/drivers/via-cuda/cuda.h>
+#include <console/chardev.h>
+#include <ddi/irq.h>
+#include <arch/asm.h>
+#include <mm/slab.h>
+#include <ddi/device.h>
+static irq_ownership_t cuda_claim(irq_t *irq)
+{
+    return IRQ_DECLINE;
+}
+static void cuda_irq_handler(irq_t *irq)
+{
+}
+cuda_instance_t *cuda_init(cuda_t *dev, inr_t inr, cir_t cir, void *cir_arg)
+{
+    cuda_instance_t *instance
+        = malloc(sizeof(cuda_instance_t), FRAME_ATOMIC);
+    if (instance) {
+        instance->cuda = dev;
+        instance->kbrdin = NULL;
+        irq_initialize(&instance->irq);
+        instance->irq.devno = device_assign_devno();
+        instance->irq.inr = inr;
+        instance->irq.claim = cuda_claim;
+        instance->irq.handler = cuda_irq_handler;
+        instance->irq.instance = instance;
+        instance->irq.cir = cir;
+        instance->irq.cir_arg = cir_arg;
+    }
+    return instance;
+}
+void cuda_wire(cuda_instance_t *instance, indev_t *kbrdin)
+{
+}
+/** @}
+ */
 Property changes:
 Added: svn:mergeinfo

 /branches/dd/kernel/genarch/src/drivers/ega/ega.c
 ,45 → 426,56
 /*
  * This function takes care of scrolling.
  */
-static void ega_check_cursor(void)
+static void ega_check_cursor(bool silent)
 {
     if (ega_cursor < EGA_SCREEN)
         return;
-    memmove((void *) videoram, (void *) (videoram + EGA_COLS * 2),
-        (EGA_SCREEN - EGA_COLS) * 2);
     memmove((void *) backbuf, (void *) (backbuf + EGA_COLS * 2),
         (EGA_SCREEN - EGA_COLS) * 2);
-    memsetw(videoram + (EGA_SCREEN - EGA_COLS) * 2, EGA_COLS, EMPTY_CHAR);
     memsetw(backbuf + (EGA_SCREEN - EGA_COLS) * 2, EGA_COLS, EMPTY_CHAR);
+    if (!silent) {
+        memmove((void *) videoram, (void *) (videoram + EGA_COLS * 2),
+            (EGA_SCREEN - EGA_COLS) * 2);
+        memsetw(videoram + (EGA_SCREEN - EGA_COLS) * 2, EGA_COLS, EMPTY_CHAR);
+    }
     ega_cursor = ega_cursor - EGA_COLS;
 }
-static void ega_show_cursor(void)
+static void ega_show_cursor(bool silent)
 {
-    pio_write_8(ega_base + EGA_INDEX_REG, 0x0a);
-    uint8_t stat = pio_read_8(ega_base + EGA_DATA_REG);
-    pio_write_8(ega_base + EGA_INDEX_REG, 0x0a);
-    pio_write_8(ega_base + EGA_DATA_REG, stat & (~(1 << 5)));
+    if (!silent) {
+        pio_write_8(ega_base + EGA_INDEX_REG, 0x0a);
+        uint8_t stat = pio_read_8(ega_base + EGA_DATA_REG);
+        pio_write_8(ega_base + EGA_INDEX_REG, 0x0a);
+        pio_write_8(ega_base + EGA_DATA_REG, stat & (~(1 << 5)));
+    }
 }
-static void ega_move_cursor(void)
+static void ega_move_cursor(bool silent)
 {
-    pio_write_8(ega_base + EGA_INDEX_REG, 0x0e);
-    pio_write_8(ega_base + EGA_DATA_REG, (uint8_t) ((ega_cursor >> 8) & 0xff));
-    pio_write_8(ega_base + EGA_INDEX_REG, 0x0f);
-    pio_write_8(ega_base + EGA_DATA_REG, (uint8_t) (ega_cursor & 0xff));
+    if (!silent) {
+        pio_write_8(ega_base + EGA_INDEX_REG, 0x0e);
+        pio_write_8(ega_base + EGA_DATA_REG, (uint8_t) ((ega_cursor >> 8) & 0xff));
+        pio_write_8(ega_base + EGA_INDEX_REG, 0x0f);
+        pio_write_8(ega_base + EGA_DATA_REG, (uint8_t) (ega_cursor & 0xff));
+    }
 }
-static void ega_sync_cursor(void)
+static void ega_sync_cursor(bool silent)
 {
-    pio_write_8(ega_base + EGA_INDEX_REG, 0x0e);
-    uint8_t hi = pio_read_8(ega_base + EGA_DATA_REG);
-    pio_write_8(ega_base + EGA_INDEX_REG, 0x0f);
-    uint8_t lo = pio_read_8(ega_base + EGA_DATA_REG);
+    if (!silent) {
+        pio_write_8(ega_base + EGA_INDEX_REG, 0x0e);
+        uint8_t hi = pio_read_8(ega_base + EGA_DATA_REG);
+        pio_write_8(ega_base + EGA_INDEX_REG, 0x0f);
+        uint8_t lo = pio_read_8(ega_base + EGA_DATA_REG);
+        ega_cursor = (hi << 8) | lo;
+    } else
+        ega_cursor = 0;
-    ega_cursor = (hi << 8) | lo;
     if (ega_cursor >= EGA_SCREEN)
         ega_cursor = 0;
 ,12 → 482,14
     if ((ega_cursor % EGA_COLS) != 0)
         ega_cursor = (ega_cursor + EGA_COLS) - ega_cursor % EGA_COLS;
-    memsetw(videoram + ega_cursor * 2, EGA_SCREEN - ega_cursor, EMPTY_CHAR);
     memsetw(backbuf + ega_cursor * 2, EGA_SCREEN - ega_cursor, EMPTY_CHAR);
-    ega_check_cursor();
-    ega_move_cursor();
-    ega_show_cursor();
+    if (!silent)
+        memsetw(videoram + ega_cursor * 2, EGA_SCREEN - ega_cursor, EMPTY_CHAR);
+    ega_check_cursor(silent);
+    ega_move_cursor(silent);
+    ega_show_cursor(silent);
 }
 static void ega_display_char(wchar_t ch, bool silent)
 ,11 → 538,9
         ega_cursor++;
         break;
     }
-    ega_check_cursor();
+    ega_check_cursor(silent);
+    ega_move_cursor(silent);
-    if (!silent)
-        ega_move_cursor();
     spinlock_unlock(&egalock);
     interrupts_restore(ipl);
 }
 ,7 → 563,7
     /* Synchronize the back buffer and cursor position. */
     memcpy(backbuf, videoram, EGA_VRAM_SIZE);
-    ega_sync_cursor();
+    ega_sync_cursor(silent);
     outdev_initialize("ega", &ega_console, &ega_ops);
     stdout = &ega_console;
 ,8 → 579,8
 void ega_redraw(void)
 {
     memcpy(videoram, backbuf, EGA_VRAM_SIZE);
-    ega_move_cursor();
-    ega_show_cursor();
+    ega_move_cursor(silent);
+    ega_show_cursor(silent);
 }
 /** @}

 /branches/dd/kernel/genarch/src/srln/srln.c
 ,20 → 41,18
 #include <arch.h>
 #include <string.h>
-static indev_t srlnout;
-indev_operations_t srlnout_ops = {
+static indev_operations_t srln_raw_ops = {
     .poll = NULL
 };
 static void ksrln(void *arg)
 {
-    indev_t *in = (indev_t *) arg;
+    srln_instance_t *instance = (srln_instance_t *) arg;
     bool cr = false;
     uint32_t escape = 0;
     while (true) {
-        wchar_t ch = _getc(in);
+        wchar_t ch = indev_pop_character(&instance->raw);
         /* ANSI escape sequence processing */
         if (escape != 0) {
 ,21 → 120,40
         if (ch == 0x7f)
             ch = '\b';
-        indev_push_character(stdin, ch);
+        indev_push_character(instance->sink, ch);
     }
 }
-void srln_init(indev_t *devin)
+srln_instance_t *srln_init(void)
 {
-    indev_initialize("srln", &srlnout, &srlnout_ops);
-    thread_t *thread
-        = thread_create(ksrln, devin, TASK, 0, "ksrln", false);
+    srln_instance_t *instance
+        = malloc(sizeof(srln_instance_t), FRAME_ATOMIC);
+    if (instance) {
+        instance->thread
+            = thread_create(ksrln, (void *) instance, TASK, 0, "ksrln", false);
+        if (!instance->thread) {
+            free(instance);
+            return NULL;
+        }
+        instance->sink = NULL;
+        indev_initialize("srln", &instance->raw, &srln_raw_ops);
+    }
-    if (thread) {
-        stdin = &srlnout;
-        thread_ready(thread);
-    }
+    return instance;
 }
+indev_t *srln_wire(srln_instance_t *instance, indev_t *sink)
+{
+    ASSERT(instance);
+    ASSERT(sink);
+    instance->sink = sink;
+    thread_ready(instance->thread);
+    return &instance->raw;
+}
 /** @}
  */

/branches/dd/kernel/generic/include/byteorder.h
36,6 → 36,7
#define KERN_BYTEORDER_H_

#include <arch/byteorder.h>
#include <arch/types.h>

#if !(defined(ARCH_IS_BIG_ENDIAN) ^ defined(ARCH_IS_LITTLE_ENDIAN))
#error The architecture must be either big-endian or little-endian.

 /branches/dd/kernel/generic/include/console/chardev.h
 ,10 → 89,13
 extern void indev_initialize(char *name, indev_t *indev,
     indev_operations_t *op);
 extern void indev_push_character(indev_t *indev, wchar_t ch);
+extern wchar_t indev_pop_character(indev_t *indev);
 extern void outdev_initialize(char *name, outdev_t *outdev,
     outdev_operations_t *op);
+extern bool check_poll(indev_t *indev);
 #endif /* KERN_CHARDEV_H_ */
 /** @}

 /branches/dd/kernel/generic/include/console/console.h
 ,17 → 40,15
 extern indev_t *stdin;
 extern outdev_t *stdout;
 extern bool silent;
+extern indev_t *stdin_wire(void);
 extern void console_init(void);
 extern void klog_init(void);
 extern void klog_update(void);
-extern bool check_poll(indev_t *indev);
 extern wchar_t getc(indev_t *indev);
-extern wchar_t _getc(indev_t *indev);
 extern count_t gets(indev_t *indev, char *buf, size_t buflen);
 extern unative_t sys_klog(int fd, const void *buf, size_t size);

 /branches/dd/kernel/generic/include/ipc/ipc.h
 ,6 → 111,25
 /* System-specific methods - only through special syscalls
  * These methods have special behaviour
  */
+/** Clone connection.
+ *
+ * The calling task clones one of its phones for the callee.
+ *
+ * - ARG1 - The caller sets ARG1 to the phone of the cloned connection.
+ *    - The callee gets the new phone from ARG1.
+ * - on answer, the callee acknowledges the new connection by sending EOK back
+ *   or the kernel closes it
+ */
+#define IPC_M_CONNECTION_CLONE  1
+/** Protocol for CONNECT - ME
+ *
+ * Through this call, the recipient learns about the new cloned connection.
+ *
+ * - ARG5 - the kernel sets ARG5 to contain the hash of the used phone
+ * - on asnwer, the callee acknowledges the new connection by sending EOK back
+ *   or the kernel closes it
+ */
+#define IPC_M_CONNECT_ME    2
 /** Protocol for CONNECT - TO - ME
  *
  * Calling process asks the callee to create a callback connection,
 ,7 → 146,7
  *                     - the allocated phoneid is passed to userspace
  *                       (on the receiving side) as ARG5 of the call.
  */
-#define IPC_M_CONNECT_TO_ME 1
+#define IPC_M_CONNECT_TO_ME 3
 /** Protocol for CONNECT - ME - TO
  *
  * Calling process asks the callee to create for him a new connection.
 ,11 → 164,11
  *                     -  recepient may forward message.
  *
  */
-#define IPC_M_CONNECT_ME_TO 2
+#define IPC_M_CONNECT_ME_TO 4
 /** This message is sent to answerbox when the phone
  * is hung up
  */
-#define IPC_M_PHONE_HUNGUP  3
+#define IPC_M_PHONE_HUNGUP  5
 /** Send as_area over IPC.
  * - ARG1 - source as_area base address
 ,7 → 178,7
  * on answer, the recipient must set:
  * - ARG1 - dst as_area base adress
  */
-#define IPC_M_SHARE_OUT     4
+#define IPC_M_SHARE_OUT     6
 /** Receive as_area over IPC.
  * - ARG1 - destination as_area base address
 ,7 → 190,7
  * - ARG1 - source as_area base address
  * - ARG2 - flags that will be used for sharing
  */
-#define IPC_M_SHARE_IN      5
+#define IPC_M_SHARE_IN      7
 /** Send data to another address space over IPC.
  * - ARG1 - source address space virtual address
 ,7 → 201,7
  * - ARG1 - final destination address space virtual address
  * - ARG2 - final size of data to be copied
  */
-#define IPC_M_DATA_WRITE    6
+#define IPC_M_DATA_WRITE    8
 /** Receive data from another address space over IPC.
  * - ARG1 - destination virtual address in the source address space
 ,13 → 212,13
  * - ARG1 - source virtual address in the destination address space
  * - ARG2 - final size of data to be copied
  */
-#define IPC_M_DATA_READ     7
+#define IPC_M_DATA_READ     9
 /** Debug the recipient.
  * - ARG1 - specifies the debug method (from udebug_method_t)
  * - other arguments are specific to the debug method
  */
-#define IPC_M_DEBUG_ALL     8
+#define IPC_M_DEBUG_ALL     10
 /* Well-known methods */
 #define IPC_M_LAST_SYSTEM   511

 /branches/dd/kernel/generic/include/ipc/ipcrsc.h
 ,8 → 35,11
 #ifndef KERN_IPCRSC_H_
 #define KERN_IPCRSC_H_
+#include <proc/task.h>
+#include <ipc/ipc.h>
 extern call_t * get_call(unative_t callid);
-extern int phone_alloc(void);
+extern int phone_alloc(task_t *t);
 extern void phone_connect(int phoneid, answerbox_t *box);
 extern void phone_dealloc(int phoneid);

 /branches/dd/kernel/generic/src/main/kinit.c
 ,19 → 218,11
     }
     /*
-     * Run user tasks with small delays
-     * to avoid intermixed klog output.
-     *
-     * TODO: This certainly does not guarantee
-     *       anything, it just works in most of the
-     *       cases. Some better way how to achieve
-     *       nice klog output should be found.
+     * Run user tasks.
      */
     for (i = 0; i < init.cnt; i++) {
-        if (programs[i].task != NULL) {
+        if (programs[i].task != NULL)
             program_ready(&programs[i]);
-            thread_usleep(10000);
-        }
     }
 #ifdef CONFIG_KCONSOLE

 /branches/dd/kernel/generic/src/main/main.c
 ,10 → 250,10
         count_t i;
         for (i = 0; i < init.cnt; i++)
             LOG("init[%" PRIc "].addr=%#" PRIp ", init[%" PRIc
-                "].size=%#" PRIs "\n", i, init.tasks[i].addr, i,
+                "].size=%#" PRIs, i, init.tasks[i].addr, i,
                 init.tasks[i].size);
     } else
-        printf("No init binaries found\n");
+        printf("No init binaries found.\n");
     LOG_EXEC(ipc_init());
     LOG_EXEC(event_init());

 /branches/dd/kernel/generic/src/interrupt/interrupt.c
 ,7 → 145,7
         if (((i + 1) % 20) == 0) {
             printf(" -- Press any key to continue -- ");
             spinlock_unlock(&exctbl_lock);
-            _getc(stdin);
+            indev_pop_character(stdin);
             spinlock_lock(&exctbl_lock);
             printf("\n");
         }

 /branches/dd/kernel/generic/src/console/console.c
 ,7 → 44,6
 #include <ipc/event.h>
 #include <ipc/irq.h>
 #include <arch.h>
-#include <func.h>
 #include <print.h>
 #include <putchar.h>
 #include <atomic.h>
 ,9 → 69,6
 /** Number of stored kernel log characters for uspace */
 static size_t klog_uspace = 0;
-/** Silence output */
-bool silent = false;
 /** Kernel log spinlock */
 SPINLOCK_INITIALIZE(klog_lock);
 ,10 → 75,28
 /** Physical memory area used for klog buffer */
 static parea_t klog_parea;
+static indev_operations_t stdin_ops = {
+    .poll = NULL
+};
+/** Silence output */
+bool silent = false;
 /** Standard input and output character devices */
 indev_t *stdin = NULL;
 outdev_t *stdout = NULL;
+indev_t *stdin_wire(void)
+{
+    if (stdin == NULL) {
+        stdin = malloc(sizeof(indev_t), FRAME_ATOMIC);
+        if (stdin != NULL)
+            indev_initialize("stdin", stdin, &stdin_ops);
+    }
+    return stdin;
+}
 /** Initialize kernel logging facility
  *
  * The shared area contains kernel cyclic buffer. Userspace application may
 ,8 → 124,14
 void grab_console(void)
 {
+    bool prev = silent;
     silent = false;
     arch_grab_console();
+    /* Force the console to print the prompt */
+    if ((stdin) && (prev))
+        indev_push_character(stdin, '\n');
 }
 void release_console(void)
 ,55 → 158,6
     return true;
 }
-bool check_poll(indev_t *indev)
-{
-    if (indev == NULL)
-        return false;
-    if (indev->op == NULL)
-        return false;
-    return (indev->op->poll != NULL);
-}
-/** Get character from input character device. Do not echo character.
- *
- * @param indev Input character device.
- * @return Character read.
- *
- */
-wchar_t _getc(indev_t *indev)
-{
-    if (atomic_get(&haltstate)) {
-        /* If we are here, we are hopefully on the processor that
-         * issued the 'halt' command, so proceed to read the character
-         * directly from input
-         */
-        if (check_poll(indev))
-            return indev->op->poll(indev);
-        /* No other way of interacting with user */
-        interrupts_disable();
-        if (CPU)
-            printf("cpu%u: ", CPU->id);
-        else
-            printf("cpu: ");
-        printf("halted (no polling input)\n");
-        cpu_halt();
-    }
-    waitq_sleep(&indev->wq);
-    ipl_t ipl = interrupts_disable();
-    spinlock_lock(&indev->lock);
-    wchar_t ch = indev->buffer[(indev->index - indev->counter) % INDEV_BUFLEN];
-    indev->counter--;
-    spinlock_unlock(&indev->lock);
-    interrupts_restore(ipl);
-    return ch;
-}
 /** Get string from input character device.
  *
  * Read characters from input character device until first occurrence
 ,7 → 177,7
     buf[offset] = 0;
     wchar_t ch;
-    while ((ch = _getc(indev)) != '\n') {
+    while ((ch = indev_pop_character(indev)) != '\n') {
         if (ch == '\b') {
             if (count > 0) {
                 /* Space, backspace, space */
 ,7 → 203,7
 /** Get character from input device & echo it to screen */
 wchar_t getc(indev_t *indev)
 {
-    wchar_t ch = _getc(indev);
+    wchar_t ch = indev_pop_character(indev);
     putchar(ch);
     return ch;
 }

/branches/dd/kernel/generic/src/console/cmd.c
956,6 → 956,7
release_console();

event_notify_0(EVENT_KCONSOLE);
indev_pop_character(stdin);

return 1;
}

 /branches/dd/kernel/generic/src/console/chardev.c
 ,6 → 35,9
 #include <console/chardev.h>
 #include <synch/waitq.h>
 #include <synch/spinlock.h>
+#include <print.h>
+#include <func.h>
+#include <arch.h>
 /** Initialize input character device.
  *
 ,6 → 82,46
     spinlock_unlock(&indev->lock);
 }
+/** Pop character from input character device.
+ *
+ * @param indev Input character device.
+ *
+ * @return Character read.
+ *
+ */
+wchar_t indev_pop_character(indev_t *indev)
+{
+    if (atomic_get(&haltstate)) {
+        /* If we are here, we are hopefully on the processor that
+         * issued the 'halt' command, so proceed to read the character
+         * directly from input
+         */
+        if (check_poll(indev))
+            return indev->op->poll(indev);
+        /* No other way of interacting with user */
+        interrupts_disable();
+        if (CPU)
+            printf("cpu%u: ", CPU->id);
+        else
+            printf("cpu: ");
+        printf("halted (no polling input)\n");
+        cpu_halt();
+    }
+    waitq_sleep(&indev->wq);
+    ipl_t ipl = interrupts_disable();
+    spinlock_lock(&indev->lock);
+    wchar_t ch = indev->buffer[(indev->index - indev->counter) % INDEV_BUFLEN];
+    indev->counter--;
+    spinlock_unlock(&indev->lock);
+    interrupts_restore(ipl);
+    return ch;
+}
 /** Initialize output character device.
  *
  * @param outdev Output character device.
 ,5 → 136,16
     outdev->op = op;
 }
+bool check_poll(indev_t *indev)
+{
+    if (indev == NULL)
+        return false;
+    if (indev->op == NULL)
+        return false;
+    return (indev->op->poll != NULL);
+}
 /** @}
  */

 /branches/dd/kernel/generic/src/console/kconsole.c
 ,7 → 245,7
     current[0] = 0;
     while (true) {
-        wchar_t ch = _getc(indev);
+        wchar_t ch = indev_pop_character(indev);
         if (ch == '\n') {
             /* Enter */
 ,7 → 582,7
         case ARG_TYPE_STRING:
             buf = (char *) cmd->argv[i].buffer;
             str_ncpy(buf, cmd->argv[i].len, cmdline + start,
-                (end - start) + 1);
+                end - start);
             break;
         case ARG_TYPE_INT:
             if (!parse_int_arg(cmdline + start, end - start,
 ,7 → 653,7
         printf("%s", msg);
     if (kcon)
-        _getc(stdin);
+        indev_pop_character(stdin);
     else
         printf("Type \"exit\" to leave the console.\n");

 /branches/dd/kernel/generic/src/proc/program.c
 ,7 → 133,7
         /* Register image as the program loader */
         ASSERT(program_loader == NULL);
         program_loader = image_addr;
-        printf("Registered program loader at 0x%" PRIp "\n",
+        LOG("Registered program loader at 0x%" PRIp "\n",
             image_addr);
         return EOK;
     }

 /branches/dd/kernel/generic/src/lib/string.c
 ,10 → 641,12
 {
     wchar_t acc;
     size_t off = 0;
+    size_t last = 0;
     while ((acc = str_decode(str, &off, STR_NO_LIMIT)) != 0) {
         if (acc == ch)
-            return (str + off);
+            return (str + last);
+        last = off;
     }
     return NULL;

 /branches/dd/kernel/generic/src/mm/slab.c
 ,7 → 936,7
 void *malloc(unsigned int size, int flags)
 {
     ASSERT(_slab_initialized);
-    ASSERT(size && size <= (1 << SLAB_MAX_MALLOC_W));
+    ASSERT(size <= (1 << SLAB_MAX_MALLOC_W));
     if (size < (1 << SLAB_MIN_MALLOC_W))
         size = (1 << SLAB_MIN_MALLOC_W);

 /branches/dd/kernel/generic/src/syscall/syscall.c
 ,9 → 59,19
     unative_t a4, unative_t a5, unative_t a6, unative_t id)
 {
     unative_t rc;
+#ifdef CONFIG_UDEBUG
+    bool debug;
+    /*
+     * Early check for undebugged tasks. We do not lock anything as this
+     * test need not be precise in either way.
+     */
+    debug = THREAD->udebug.active;
-#ifdef CONFIG_UDEBUG
-    udebug_syscall_event(a1, a2, a3, a4, a5, a6, id, 0, false);
+    if (debug) {
+        udebug_syscall_event(a1, a2, a3, a4, a5, a6, id, 0, false);
+    }
 #endif
     if (id < SYSCALL_END) {
 ,14 → 86,17
         thread_exit();
 #ifdef CONFIG_UDEBUG
-    udebug_syscall_event(a1, a2, a3, a4, a5, a6, id, rc, true);
+    if (debug) {
+        udebug_syscall_event(a1, a2, a3, a4, a5, a6, id, rc, true);
-    /*
-     * Stopping point needed for tasks that only invoke non-blocking
-     * system calls.
-     */
-    udebug_stoppable_begin();
-    udebug_stoppable_end();
+        /*
+         * Stopping point needed for tasks that only invoke
+         * non-blocking system calls. Not needed if the task
+         * is not being debugged (it cannot block here).
+         */
+        udebug_stoppable_begin();
+        udebug_stoppable_end();
+    }
 #endif
     return rc;

 /branches/dd/kernel/generic/src/ipc/ipcrsc.c
 ,27 → 160,29
     return result;
 }
-/** Allocate new phone slot in the current TASK structure.
+/** Allocate new phone slot in the specified task.
  *
+ * @param t     Task for which to allocate a new phone.
+ *
  * @return      New phone handle or -1 if the phone handle limit is
  *          exceeded.
  */
-int phone_alloc(void)
+int phone_alloc(task_t *t)
 {
     int i;
-    spinlock_lock(&TASK->lock);
+    spinlock_lock(&t->lock);
     for (i = 0; i < IPC_MAX_PHONES; i++) {
-        if (TASK->phones[i].state == IPC_PHONE_HUNGUP &&
-            atomic_get(&TASK->phones[i].active_calls) == 0)
-            TASK->phones[i].state = IPC_PHONE_FREE;
+        if (t->phones[i].state == IPC_PHONE_HUNGUP &&
+            atomic_get(&t->phones[i].active_calls) == 0)
+            t->phones[i].state = IPC_PHONE_FREE;
-        if (TASK->phones[i].state == IPC_PHONE_FREE) {
-            TASK->phones[i].state = IPC_PHONE_CONNECTING;
+        if (t->phones[i].state == IPC_PHONE_FREE) {
+            t->phones[i].state = IPC_PHONE_CONNECTING;
             break;
         }
     }
-    spinlock_unlock(&TASK->lock);
+    spinlock_unlock(&t->lock);
     if (i == IPC_MAX_PHONES)
         return -1;

 /branches/dd/kernel/generic/src/ipc/kbox.c
 ,10 → 84,10
     interrupts_restore(ipl);
     if (have_kb_thread) {
-        LOG("join kb.thread..\n");
+        LOG("Join kb.thread.");
         thread_join(TASK->kb.thread);
         thread_detach(TASK->kb.thread);
-        LOG("join done\n");
+        LOG("...join done.");
         TASK->kb.thread = NULL;
     }
 ,12 → 108,10
 {
     ipl_t ipl;
-    LOG("kbox_proc_phone_hungup()\n");
     /* Was it our debugger, who hung up? */
     if (call->sender == TASK->udebug.debugger) {
         /* Terminate debugging session (if any). */
-        LOG("kbox: terminate debug session\n");
+        LOG("Terminate debugging session.");
         ipl = interrupts_disable();
         spinlock_lock(&TASK->lock);
         udebug_task_cleanup(TASK);
 ,10 → 118,10
         spinlock_unlock(&TASK->lock);
         interrupts_restore(ipl);
     } else {
-        LOG("kbox: was not debugger\n");
+        LOG("Was not debugger.");
     }
-    LOG("kbox: continue with hangup message\n");
+    LOG("Continue with hangup message.");
     IPC_SET_RETVAL(call->data, 0);
     ipc_answer(&TASK->kb.box, call);
 ,7 → 143,7
         }
         mutex_unlock(&TASK->kb.cleanup_lock);
-        LOG("phone list is empty\n");
+        LOG("Phone list is empty.");
         *last = true;
     } else {
         *last = false;
 ,7 → 167,7
     bool done;
     (void)arg;
-    LOG("kbox_thread_proc()\n");
+    LOG("Starting.");
     done = false;
     while (!done) {
 ,7 → 199,7
         }
     }
-    LOG("kbox: finished\n");
+    LOG("Exiting.");
 }
 ,7 → 248,7
         return EINVAL;
     }
-    newphid = phone_alloc();
+    newphid = phone_alloc(TASK);
     if (newphid < 0) {
         mutex_unlock(&ta->kb.cleanup_lock);
         return ELIMIT;

 /branches/dd/kernel/generic/src/ipc/sysipc.c
 ,6 → 93,8
 static inline int method_is_forwardable(unative_t method)
 {
     switch (method) {
+    case IPC_M_CONNECTION_CLONE:
+    case IPC_M_CONNECT_ME:
     case IPC_M_PHONE_HUNGUP:
         /* This message is meant only for the original recipient. */
         return 0;
 ,6 → 142,8
 static inline int answer_need_old(call_t *call)
 {
     switch (IPC_GET_METHOD(call->data)) {
+    case IPC_M_CONNECTION_CLONE:
+    case IPC_M_CONNECT_ME:
     case IPC_M_CONNECT_TO_ME:
     case IPC_M_CONNECT_ME_TO:
     case IPC_M_SHARE_OUT:
 ,9 → 186,48
     if (!olddata)
         return 0;
-    if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_TO_ME) {
+    if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECTION_CLONE) {
+        phoneid = IPC_GET_ARG1(*olddata);
+        phone_t *phone = &TASK->phones[phoneid];
+        if (IPC_GET_RETVAL(answer->data) != EOK) {
+            /*
+             * The recipient of the cloned phone rejected the offer.
+             * In this case, the connection was established at the
+             * request time and therefore we need to slam the phone.
+             * We don't merely hangup as that would result in
+             * sending IPC_M_HUNGUP to the third party on the
+             * other side of the cloned phone.
+             */
+            mutex_lock(&phone->lock);
+            if (phone->state == IPC_PHONE_CONNECTED) {
+                spinlock_lock(&phone->callee->lock);
+                list_remove(&phone->link);
+                phone->state = IPC_PHONE_SLAMMED;
+                spinlock_unlock(&phone->callee->lock);
+            }
+            mutex_unlock(&phone->lock);
+        }
+    } else if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_ME) {
+        phone_t *phone = (phone_t *)IPC_GET_ARG5(*olddata);
+        if (IPC_GET_RETVAL(answer->data) != EOK) {
+            /*
+             * The other party on the cloned phoned rejected our
+             * request for connection on the protocol level.
+             * We need to break the connection without sending
+             * IPC_M_HUNGUP back.
+             */
+            mutex_lock(&phone->lock);
+            if (phone->state == IPC_PHONE_CONNECTED) {
+                spinlock_lock(&phone->callee->lock);
+                list_remove(&phone->link);
+                phone->state = IPC_PHONE_SLAMMED;
+                spinlock_unlock(&phone->callee->lock);
+            }
+            mutex_unlock(&phone->lock);
+        }
+    } else if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_TO_ME) {
         phoneid = IPC_GET_ARG5(*olddata);
-        if (IPC_GET_RETVAL(answer->data)) {
+        if (IPC_GET_RETVAL(answer->data) != EOK) {
             /* The connection was not accepted */
             phone_dealloc(phoneid);
         } else {
 ,7 → 239,7
         }
     } else if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_ME_TO) {
         /* If the users accepted call, connect */
-        if (!IPC_GET_RETVAL(answer->data)) {
+        if (IPC_GET_RETVAL(answer->data) == EOK) {
             ipc_phone_connect((phone_t *) IPC_GET_ARG5(*olddata),
                 &TASK->answerbox);
         }
 ,8 → 351,48
     int rc;
     switch (IPC_GET_METHOD(call->data)) {
+    case IPC_M_CONNECTION_CLONE: {
+        phone_t *cloned_phone;
+        GET_CHECK_PHONE(cloned_phone, IPC_GET_ARG1(call->data),
+            return ENOENT);
+        if (cloned_phone < phone) {
+            mutex_lock(&cloned_phone->lock);
+            mutex_lock(&phone->lock);
+        } else {
+            mutex_lock(&phone->lock);
+            mutex_lock(&cloned_phone->lock);
+        }
+        if ((cloned_phone->state != IPC_PHONE_CONNECTED) ||
+            phone->state != IPC_PHONE_CONNECTED) {
+            mutex_unlock(&cloned_phone->lock);
+            mutex_unlock(&phone->lock);
+            return EINVAL;
+        }
+        /*
+         * We can be pretty sure now that both tasks exist and we are
+         * connected to them. As we continue to hold the phone locks,
+         * we are effectively preventing them from finishing their
+         * potential cleanup.
+         */
+        newphid = phone_alloc(phone->callee->task);
+        if (newphid < 0) {
+            mutex_unlock(&cloned_phone->lock);
+            mutex_unlock(&phone->lock);
+            return ELIMIT;
+        }
+        ipc_phone_connect(&phone->callee->task->phones[newphid],
+            cloned_phone->callee);
+        mutex_unlock(&cloned_phone->lock);
+        mutex_unlock(&phone->lock);
+        /* Set the new phone for the callee. */
+        IPC_SET_ARG1(call->data, newphid);
+        break;
+    }
+    case IPC_M_CONNECT_ME:
+        IPC_SET_ARG5(call->data, (unative_t) phone);
+        break;
     case IPC_M_CONNECT_ME_TO:
-        newphid = phone_alloc();
+        newphid = phone_alloc(TASK);
         if (newphid < 0)
             return ELIMIT;
         /* Set arg5 for server */
 ,7 → 415,7
         src = IPC_GET_ARG1(call->data);
         size = IPC_GET_ARG2(call->data);
-        if ((size <= 0) || (size > DATA_XFER_LIMIT))
+        if (size > DATA_XFER_LIMIT)
             return ELIMIT;
         call->buffer = (uint8_t *) malloc(size, 0);
 ,7 → 482,7
     int phoneid;
     if (IPC_GET_METHOD(call->data) == IPC_M_CONNECT_TO_ME) {
-        phoneid = phone_alloc();
+        phoneid = phone_alloc(TASK);
         if (phoneid < 0) { /* Failed to allocate phone */
             IPC_SET_RETVAL(call->data, ELIMIT);
             ipc_answer(box, call);

 /branches/dd/kernel/generic/src/ipc/ipc.c
 ,12 → 328,10
         list_remove(&phone->link);
         spinlock_unlock(&box->lock);
-        if (phone->state != IPC_PHONE_SLAMMED) {
-            call = ipc_call_alloc(0);
-            IPC_SET_METHOD(call->data, IPC_M_PHONE_HUNGUP);
-            call->flags |= IPC_CALL_DISCARD_ANSWER;
-            _ipc_call(phone, box, call);
-        }
+        call = ipc_call_alloc(0);
+        IPC_SET_METHOD(call->data, IPC_M_PHONE_HUNGUP);
+        call->flags |= IPC_CALL_DISCARD_ANSWER;
+        _ipc_call(phone, box, call);
     }
     phone->state = IPC_PHONE_HUNGUP;

 /branches/dd/kernel/generic/src/udebug/udebug.c
 ,27 → 98,6
     waitq_sleep_finish(wq, rc, ipl);
 }
-/** Do a preliminary check that a debugging session is in progress.
- *
- * This only requires the THREAD->udebug.lock mutex (and not TASK->udebug.lock
- * mutex). For an undebugged task, this will never block (while there could be
- * collisions by different threads on the TASK mutex), thus improving SMP
- * perormance for undebugged tasks.
- *
- * @return  True if the thread was in a debugging session when the function
- *      checked, false otherwise.
- */
-static bool udebug_thread_precheck(void)
-{
-    bool res;
-    mutex_lock(&THREAD->udebug.lock);
-    res = THREAD->udebug.active;
-    mutex_unlock(&THREAD->udebug.lock);
-    return res;
-}
 /** Start of stoppable section.
  *
  * A stoppable section is a section of code where if the thread can be stoped. In other words,
 ,11 → 116,6
     ASSERT(THREAD);
     ASSERT(TASK);
-    /* Early check for undebugged tasks */
-    if (!udebug_thread_precheck()) {
-        return;
-    }
     mutex_lock(&TASK->udebug.lock);
     nsc = --TASK->udebug.not_stoppable_count;
 ,11 → 176,6
  */
 void udebug_stoppable_end(void)
 {
-    /* Early check for undebugged tasks */
-    if (!udebug_thread_precheck()) {
-        return;
-    }
 restart:
     mutex_lock(&TASK->udebug.lock);
     mutex_lock(&THREAD->udebug.lock);
 ,11 → 224,6
     etype = end_variant ? UDEBUG_EVENT_SYSCALL_E : UDEBUG_EVENT_SYSCALL_B;
-    /* Early check for undebugged tasks */
-    if (!udebug_thread_precheck()) {
-        return;
-    }
     mutex_lock(&TASK->udebug.lock);
     mutex_lock(&THREAD->udebug.lock);
 ,7 → 235,7
         return;
     }
-    //printf("udebug_syscall_event\n");
+    /* Fill in the GO response. */
     call = THREAD->udebug.go_call;
     THREAD->udebug.go_call = NULL;
 ,7 → 243,6
     IPC_SET_ARG1(call->data, etype);
     IPC_SET_ARG2(call->data, id);
     IPC_SET_ARG3(call->data, rc);
-    //printf("udebug_syscall_event/ipc_answer\n");
     THREAD->udebug.syscall_args[0] = a1;
     THREAD->udebug.syscall_args[1] = a2;
 ,21 → 292,19
     thread_attach(t, ta);
-    LOG("udebug_thread_b_event\n");
-    LOG("- check state\n");
+    LOG("Check state");
     /* Must only generate events when in debugging session */
     if (THREAD->udebug.active != true) {
-        LOG("- udebug.active: %s, udebug.go: %s\n",
-            THREAD->udebug.active ? "yes(+)" : "no(-)",
-            THREAD->udebug.go ? "yes(-)" : "no(+)");
+        LOG("udebug.active: %s, udebug.go: %s",
+            THREAD->udebug.active ? "Yes(+)" : "No",
+            THREAD->udebug.go ? "Yes(-)" : "No");
         mutex_unlock(&THREAD->udebug.lock);
         mutex_unlock(&TASK->udebug.lock);
         return;
     }
-    LOG("- trigger event\n");
+    LOG("Trigger event");
     call = THREAD->udebug.go_call;
     THREAD->udebug.go_call = NULL;
     IPC_SET_RETVAL(call->data, 0);
 ,7 → 324,7
     mutex_unlock(&THREAD->udebug.lock);
     mutex_unlock(&TASK->udebug.lock);
-    LOG("- sleep\n");
+    LOG("Wait for Go");
     udebug_wait_for_go(&THREAD->udebug.go_wq);
 }
 ,21 → 340,19
     mutex_lock(&TASK->udebug.lock);
     mutex_lock(&THREAD->udebug.lock);
-    LOG("udebug_thread_e_event\n");
-    LOG("- check state\n");
+    LOG("Check state");
     /* Must only generate events when in debugging session. */
     if (THREAD->udebug.active != true) {
-/*      printf("- udebug.active: %s, udebug.go: %s\n",
-            THREAD->udebug.active ? "yes(+)" : "no(-)",
-            THREAD->udebug.go ? "yes(-)" : "no(+)");*/
+        LOG("udebug.active: %s, udebug.go: %s",
+            THREAD->udebug.active ? "Yes" : "No",
+            THREAD->udebug.go ? "Yes" : "No");
         mutex_unlock(&THREAD->udebug.lock);
         mutex_unlock(&TASK->udebug.lock);
         return;
     }
-    LOG("- trigger event\n");
+    LOG("Trigger event");
     call = THREAD->udebug.go_call;
     THREAD->udebug.go_call = NULL;
     IPC_SET_RETVAL(call->data, 0);
 ,15 → 391,13
     int flags;
     ipl_t ipl;
-    LOG("udebug_task_cleanup()\n");
-    LOG("task %" PRIu64 "\n", ta->taskid);
     if (ta->udebug.dt_state != UDEBUG_TS_BEGINNING &&
         ta->udebug.dt_state != UDEBUG_TS_ACTIVE) {
-        LOG("udebug_task_cleanup(): task not being debugged\n");
         return EINVAL;
     }
+    LOG("Task %" PRIu64, ta->taskid);
     /* Finish debugging of all userspace threads */
     for (cur = ta->th_head.next; cur != &ta->th_head; cur = cur->next) {
         t = list_get_instance(cur, thread_t, th_link);
 ,7 → 427,7
                 t->udebug.go = false;
                 /* Answer GO call */
-                LOG("answer GO call with EVENT_FINISHED\n");
+                LOG("Answer GO call with EVENT_FINISHED.");
                 IPC_SET_RETVAL(t->udebug.go_call->data, 0);
                 IPC_SET_ARG1(t->udebug.go_call->data,
                     UDEBUG_EVENT_FINISHED);

 /branches/dd/kernel/generic/src/udebug/udebug_ops.c
 ,15 → 181,11
     thread_t *t;
     link_t *cur;
-    LOG("udebug_begin()\n");
+    LOG("Debugging task %llu", TASK->taskid);
     mutex_lock(&TASK->udebug.lock);
-    LOG("debugging task %llu\n", TASK->taskid);
     if (TASK->udebug.dt_state != UDEBUG_TS_INACTIVE) {
         mutex_unlock(&TASK->udebug.lock);
-        LOG("udebug_begin(): busy error\n");
         return EBUSY;
     }
 ,10 → 213,6
     }
     mutex_unlock(&TASK->udebug.lock);
-    LOG("udebug_begin() done (%s)\n",
-        reply ? "reply" : "stoppability wait");
     return reply;
 }
 ,13 → 225,10
 {
     int rc;
-    LOG("udebug_end()\n");
+    LOG("Task %" PRIu64, TASK->taskid);
     mutex_lock(&TASK->udebug.lock);
-    LOG("task %" PRIu64 "\n", TASK->taskid);
     rc = udebug_task_cleanup(TASK);
     mutex_unlock(&TASK->udebug.lock);
     return rc;
 ,19 → 243,16
  */
 int udebug_set_evmask(udebug_evmask_t mask)
 {
-    LOG("udebug_set_mask()\n");
+    LOG("mask = 0x%x", mask);
     mutex_lock(&TASK->udebug.lock);
     if (TASK->udebug.dt_state != UDEBUG_TS_ACTIVE) {
         mutex_unlock(&TASK->udebug.lock);
-        LOG("udebug_set_mask(): not active debuging session\n");
         return EINVAL;
     }
     TASK->udebug.evmask = mask;
     mutex_unlock(&TASK->udebug.lock);
     return 0;
 ,7 → 303,7
 {
     int rc;
-    LOG("udebug_stop()\n");
+    LOG("udebug_stop()");
     /*
      * On success, this will lock t->udebug.lock. Note that this makes sure
 ,7 → 326,6
     /*
      * Answer GO call.
      */
-    LOG("udebug_stop - answering go call\n");
     /* Make sure nobody takes this call away from us. */
     call = t->udebug.go_call;
 ,7 → 333,6
     IPC_SET_RETVAL(call->data, 0);
     IPC_SET_ARG1(call->data, UDEBUG_EVENT_STOP);
-    LOG("udebug_stop/ipc_answer\n");
     THREAD->udebug.cur_event = UDEBUG_EVENT_STOP;
 ,7 → 342,6
     ipc_answer(&TASK->answerbox, call);
     mutex_unlock(&TASK->udebug.lock);
-    LOG("udebog_stop/done\n");
     return 0;
 }
 ,7 → 375,7
     int flags;
     size_t max_ids;
-    LOG("udebug_thread_read()\n");
+    LOG("udebug_thread_read()");
     /* Allocate a buffer to hold thread IDs */
     id_buffer = malloc(buf_size, 0);

 /branches/dd/kernel/arch/sparc64/include/atomic.h
 ,7 → 123,7
         "ldx %0, %2\n"
         "brz %2, 0b\n"
         "nop\n"
-        "ba 1b\n"
+        "ba %xcc, 1b\n"
         "nop\n"
     "2:\n"
         : "+m" (*((uint64_t *) x)), "+r" (tmp1), "+r" (tmp2) : "r" (0)

 /branches/dd/kernel/arch/sparc64/include/trap/trap_table.h
 ,7 → 100,7
 .macro PREEMPTIBLE_HANDLER f
     sethi %hi(\f), %g1
-    b preemptible_handler
+    ba %xcc, preemptible_handler
     or %g1, %lo(\f), %g1
 .endm

 /branches/dd/kernel/arch/sparc64/include/drivers/sgcn.h
 ,6 → 37,7
 #include <arch/types.h>
 #include <console/chardev.h>
+#include <proc/thread.h>
 /* number of bytes in the TOC magic, including the NULL-terminator */
 #define TOC_MAGIC_BYTES     8
 ,11 → 117,17
     uint32_t out_wrptr;
 } __attribute__ ((packed)) sgcn_buffer_header_t;
-void sgcn_grab(void);
-void sgcn_release(void);
-indev_t *sgcnin_init(void);
-void sgcnout_init(void);
+typedef struct {
+    thread_t *thread;
+    indev_t *srlnin;
+} sgcn_instance_t;
+extern void sgcn_grab(void);
+extern void sgcn_release(void);
+extern sgcn_instance_t *sgcnin_init(void);
+extern void sgcnin_wire(sgcn_instance_t *, indev_t *);
+extern void sgcnout_init(void);
 #endif
 /** @}

 /branches/dd/kernel/arch/sparc64/include/drivers/kbd.h
 ,7 → 26,7
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup sparc64
+/** @addtogroup sparc64
  * @{
  */
 /** @file
 ,15 → 38,6
 #include <arch/types.h>
 #include <genarch/ofw/ofw_tree.h>
-typedef enum {
-    KBD_UNKNOWN,
-    KBD_Z8530,
-    KBD_NS16550,
-    KBD_SGCN
-} kbd_type_t;
-extern kbd_type_t kbd_type;
 extern void kbd_init(ofw_tree_node_t *node);
 #endif

 /branches/dd/kernel/arch/sparc64/src/asm.S
 ,12 → 225,12
 .global memsetb
 memsetb:
-    b _memsetb
+    ba %xcc, _memsetb
     nop
 .global memsetw
 memsetw:
-    b _memsetw
+    ba %xcc, _memsetw
     nop

 /branches/dd/kernel/arch/sparc64/src/console.c
 ,7 → 26,7
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup sparc64
+/** @addtogroup sparc64
  * @{
  */
 /** @file
 ,10 → 92,15
 static void serengeti_init(void)
 {
 #ifdef CONFIG_SGCN_KBD
-    indev_t *kbrdin;
-    kbrdin = sgcnin_init();
-    if (kbrdin)
-        srln_init(kbrdin);
+    sgcn_instance_t *sgcn_instance = sgcnin_init();
+    if (sgcn_instance) {
+        srln_instance_t *srln_instance = srln_init();
+        if (srln_instance) {
+            indev_t *sink = stdin_wire();
+            indev_t *srln = srln_wire(srln_instance, sink);
+            sgcnin_wire(sgcn_instance, srln);
+        }
+    }
 #endif
 #ifdef CONFIG_SGCN_PRN
     sgcnout_init();
 ,15 → 140,9
     scr_redraw();
 #endif
-    switch (kbd_type) {
 #ifdef CONFIG_SGCN_KBD
-    case KBD_SGCN:
-        sgcn_grab();
-        break;
+    sgcn_grab();
 #endif
-    default:
-        break;
-    }
 }
 /** Return console to userspace
 ,15 → 150,9
  */
 void arch_release_console(void)
 {
-    switch (kbd_type) {
 #ifdef CONFIG_SGCN_KBD
-    case KBD_SGCN:
-        sgcn_release();
-        break;
+    sgcn_release();
 #endif
-    default:
-        break;
-    }
 }
 /** @}

 /branches/dd/kernel/arch/sparc64/src/trap/trap_table.S
 ,7 → 341,7
 .org trap_table + (TT_TRAP_INSTRUCTION_0+\cur)*ENTRY_SIZE
 .global trap_instruction_\cur\()_tl0
 trap_instruction_\cur\()_tl0:
-    ba trap_instruction_handler
+    ba %xcc, trap_instruction_handler
     mov \cur, %g2
 .endr
 ,7 → 480,7
     cmp %g3, 1
     be %xcc, 1f
     nop
-:  ba 0b                   ! this is for debugging, if we ever get here
+:  ba %xcc, 0b             ! this is for debugging, if we ever get here
     nop                 ! it will be easy to find
 :
 ,7 → 545,7
     flush %l0
 .if NOT(\is_syscall)
-    ba 1f
+    ba %xcc, 1f
     nop
 :
     save %sp, -PREEMPTIBLE_HANDLER_STACK_FRAME_SIZE, %sp
 ,7 → 774,7
     and %g3, NWINDOWS - 1, %g3
     wrpr %g3, 0, %cwp           ! switch to the preceeding window
-    ba 0b
+    ba %xcc, 0b
     inc %g4
 :

 /branches/dd/kernel/arch/sparc64/src/mm/tlb.c
 ,38 → 497,7
     dtlb_sfsr_write(0);
 }
-#if defined (US3)
-/** Invalidates given TLB entry if and only if it is non-locked or global.
- *
- * @param tlb       TLB number (one of TLB_DSMALL, TLB_DBIG_0, TLB_DBIG_1,
- *          TLB_ISMALL, TLB_IBIG).
- * @param entry     Entry index within the given TLB.
- */
-static void tlb_invalidate_entry(int tlb, index_t entry)
-{
-    tlb_data_t d;
-    tlb_tag_read_reg_t t;
-    if (tlb == TLB_DSMALL || tlb == TLB_DBIG_0 || tlb == TLB_DBIG_1) {
-        d.value = dtlb_data_access_read(tlb, entry);
-        if (!d.l || d.g) {
-            t.value = dtlb_tag_read_read(tlb, entry);
-            d.v = false;
-            dtlb_tag_access_write(t.value);
-            dtlb_data_access_write(tlb, entry, d.value);
-        }
-    } else if (tlb == TLB_ISMALL || tlb == TLB_IBIG) {
-        d.value = itlb_data_access_read(tlb, entry);
-        if (!d.l || d.g) {
-            t.value = itlb_tag_read_read(tlb, entry);
-            d.v = false;
-            itlb_tag_access_write(t.value);
-            itlb_data_access_write(tlb, entry, d.value);
-        }
-    }
-}
-#endif
+#if defined (US)
 /** Invalidate all unlocked ITLB and DTLB entries. */
 void tlb_invalidate_all(void)
 {
 ,7 → 512,6
      * be safe to invalidate them as late as now.
      */
-#if defined (US)
     tlb_data_t d;
     tlb_tag_read_reg_t t;
 ,22 → 535,19
         }
     }
+}
 #elif defined (US3)
-    for (i = 0; i < tlb_ismall_size(); i++)
-        tlb_invalidate_entry(TLB_ISMALL, i);
-    for (i = 0; i < tlb_ibig_size(); i++)
-        tlb_invalidate_entry(TLB_IBIG, i);
-    for (i = 0; i < tlb_dsmall_size(); i++)
-        tlb_invalidate_entry(TLB_DSMALL, i);
-    for (i = 0; i < tlb_dbig_size(); i++)
-        tlb_invalidate_entry(TLB_DBIG_0, i);
-    for (i = 0; i < tlb_dbig_size(); i++)
-        tlb_invalidate_entry(TLB_DBIG_1, i);
+/** Invalidate all unlocked ITLB and DTLB entries. */
+void tlb_invalidate_all(void)
+{
+    itlb_demap(TLB_DEMAP_ALL, 0, 0);
+    dtlb_demap(TLB_DEMAP_ALL, 0, 0);
+}
 #endif
-}
 /** Invalidate all ITLB and DTLB entries that belong to specified ASID
  * (Context).
  *

/branches/dd/kernel/arch/sparc64/src/dummy.s
42,5 → 42,5

.global cpu_halt
cpu_halt:
b cpu_halt
ba %xcc, cpu_halt
nop

 /branches/dd/kernel/arch/sparc64/src/drivers/kbd.c
 ,100 → 54,140
 #include <print.h>
 #include <sysinfo/sysinfo.h>
-kbd_type_t kbd_type = KBD_UNKNOWN;
 #ifdef CONFIG_SUN_KBD
-/** Initialize keyboard.
- *
- * Traverse OpenFirmware device tree in order to find necessary
- * info about the keyboard device.
- *
- * @param node Keyboard device node.
- */
-void kbd_init(ofw_tree_node_t *node)
+#ifdef CONFIG_Z8530
+static bool kbd_z8530_init(ofw_tree_node_t *node)
 {
-    size_t offset;
-    uintptr_t aligned_addr;
-    ofw_tree_property_t *prop;
-    const char *name;
+    const char *name = ofw_tree_node_name(node);
+    if (str_cmp(name, "zs") != 0)
+        return false;
+    /*
+     * Read 'interrupts' property.
+     */
+    ofw_tree_property_t *prop = ofw_tree_getprop(node, "interrupts");
+    if ((!prop) || (!prop->value)) {
+        printf("z8530: Unable to find interrupts property\n");
+        return false;
+    }
+    uint32_t interrupts = *((uint32_t *) prop->value);
+    /*
+     * Read 'reg' property.
+     */
+    prop = ofw_tree_getprop(node, "reg");
+    if ((!prop) || (!prop->value)) {
+        printf("z8530: Unable to find reg property\n");
+        return false;
+    }
+    size_t size = ((ofw_fhc_reg_t *) prop->value)->size;
+    uintptr_t pa;
+    if (!ofw_fhc_apply_ranges(node->parent,
+        ((ofw_fhc_reg_t *) prop->value), &pa)) {
+        printf("z8530: Failed to determine address\n");
+        return false;
+    }
+    inr_t inr;
     cir_t cir;
     void *cir_arg;
+    if (!ofw_fhc_map_interrupt(node->parent,
+        ((ofw_fhc_reg_t *) prop->value), interrupts, &inr, &cir,
+        &cir_arg)) {
+        printf("z8530: Failed to determine interrupt\n");
+        return false;
+    }
-#ifdef CONFIG_NS16550
-    ns16550_t *ns16550;
-#endif
-#ifdef CONFIG_Z8530
-    z8530_t *z8530;
-#endif
+    /*
+     * We need to pass aligned address to hw_map().
+     * However, the physical keyboard address can
+     * be pretty much unaligned, depending on the
+     * underlying controller.
+     */
+    uintptr_t aligned_addr = ALIGN_DOWN(pa, PAGE_SIZE);
+    size_t offset = pa - aligned_addr;
-    name = ofw_tree_node_name(node);
+    z8530_t *z8530 = (z8530_t *)
+        (hw_map(aligned_addr, offset + size) + offset);
+    z8530_instance_t *z8530_instance = z8530_init(z8530, inr, cir, cir_arg);
+    if (z8530_instance) {
+        kbrd_instance_t *kbrd_instance = kbrd_init();
+        if (kbrd_instance) {
+            indev_t *sink = stdin_wire();
+            indev_t *kbrd = kbrd_wire(kbrd_instance, sink);
+            z8530_wire(z8530_instance, kbrd);
+        }
+    }
     /*
-     * Determine keyboard serial controller type.
+     * This is the necessary evil until the userspace drivers are
+     * entirely self-sufficient.
      */
-    if (str_cmp(name, "zs") == 0)
-        kbd_type = KBD_Z8530;
-    else if (str_cmp(name, "su") == 0)
-        kbd_type = KBD_NS16550;
+    sysinfo_set_item_val("kbd", NULL, true);
+    sysinfo_set_item_val("kbd.inr", NULL, inr);
+    sysinfo_set_item_val("kbd.address.kernel", NULL,
+        (uintptr_t) z8530);
+    sysinfo_set_item_val("kbd.address.physical", NULL, pa);
+    sysinfo_set_item_val("kbd.type.z8530", NULL, true);
-    if (kbd_type == KBD_UNKNOWN) {
-        printf("Unknown keyboard device.\n");
-        return;
-    }
+    return true;
+}
+#endif /* CONFIG_Z8530 */
+#ifdef CONFIG_NS16550
+static bool kbd_ns16550_init(ofw_tree_node_t *node)
+{
+    const char *name = ofw_tree_node_name(node);
+    if (str_cmp(name, "su") != 0)
+        return false;
     /*
      * Read 'interrupts' property.
      */
-    uint32_t interrupts;
-    prop = ofw_tree_getprop(node, "interrupts");
-    if ((!prop) || (!prop->value))
-        panic("Cannot find 'interrupt' property.");
-    interrupts = *((uint32_t *) prop->value);
+    ofw_tree_property_t *prop = ofw_tree_getprop(node, "interrupts");
+    if ((!prop) || (!prop->value)) {
+        printf("ns16550: Unable to find interrupts property\n");
+        return false;
+    }
+    uint32_t interrupts = *((uint32_t *) prop->value);
     /*
      * Read 'reg' property.
      */
     prop = ofw_tree_getprop(node, "reg");
-    if ((!prop) || (!prop->value))
-        panic("Cannot find 'reg' property.");
+    if ((!prop) || (!prop->value)) {
+        printf("ns16550: Unable to find reg property\n");
+        return false;
+    }
+    size_t size = ((ofw_ebus_reg_t *) prop->value)->size;
     uintptr_t pa;
-    size_t size;
+    if (!ofw_ebus_apply_ranges(node->parent,
+        ((ofw_ebus_reg_t *) prop->value), &pa)) {
+        printf("ns16550: Failed to determine address\n");
+        return false;
+    }
     inr_t inr;
-    switch (kbd_type) {
-    case KBD_Z8530:
-        size = ((ofw_fhc_reg_t *) prop->value)->size;
-        if (!ofw_fhc_apply_ranges(node->parent,
-            ((ofw_fhc_reg_t *) prop->value), &pa)) {
-            printf("Failed to determine keyboard address.\n");
-            return;
-        }
-        if (!ofw_fhc_map_interrupt(node->parent,
-            ((ofw_fhc_reg_t *) prop->value), interrupts, &inr, &cir,
-            &cir_arg)) {
-            printf("Failed to determine keyboard interrupt.\n");
-            return;
-        }
-        break;
-    case KBD_NS16550:
-        size = ((ofw_ebus_reg_t *) prop->value)->size;
-        if (!ofw_ebus_apply_ranges(node->parent,
-            ((ofw_ebus_reg_t *) prop->value), &pa)) {
-            printf("Failed to determine keyboard address.\n");
-            return;
-        }
-        if (!ofw_ebus_map_interrupt(node->parent,
-            ((ofw_ebus_reg_t *) prop->value), interrupts, &inr, &cir,
-            &cir_arg)) {
-            printf("Failed to determine keyboard interrupt.\n");
-            return;
-        };
-        break;
-    default:
-        panic("Unexpected keyboard type.");
+    cir_t cir;
+    void *cir_arg;
+    if (!ofw_ebus_map_interrupt(node->parent,
+        ((ofw_ebus_reg_t *) prop->value), interrupts, &inr, &cir,
+        &cir_arg)) {
+        printf("ns16550: Failed to determine interrupt\n");
+        return false;
     }
     /*
 ,59 → 196,58
      * be pretty much unaligned, depending on the
      * underlying controller.
      */
-    aligned_addr = ALIGN_DOWN(pa, PAGE_SIZE);
-    offset = pa - aligned_addr;
+    uintptr_t aligned_addr = ALIGN_DOWN(pa, PAGE_SIZE);
+    size_t offset = pa - aligned_addr;
-    switch (kbd_type) {
+    ns16550_t *ns16550 = (ns16550_t *)
+       (hw_map(aligned_addr, offset + size) + offset);
+    ns16550_instance_t *ns16550_instance = ns16550_init(ns16550, inr, cir, cir_arg);
+    if (ns16550_instance) {
+        kbrd_instance_t *kbrd_instance = kbrd_init();
+        if (kbrd_instance) {
+            indev_t *sink = stdin_wire();
+            indev_t *kbrd = kbrd_wire(kbrd_instance, sink);
+            ns16550_wire(ns16550_instance, kbrd);
+        }
+    }
+    /*
+     * This is the necessary evil until the userspace drivers are
+     * entirely self-sufficient.
+     */
+    sysinfo_set_item_val("kbd", NULL, true);
+    sysinfo_set_item_val("kbd.inr", NULL, inr);
+    sysinfo_set_item_val("kbd.address.kernel", NULL,
+        (uintptr_t) ns16550);
+    sysinfo_set_item_val("kbd.address.physical", NULL, pa);
+    sysinfo_set_item_val("kbd.type.ns16550", NULL, true);
+    return true;
+}
+#endif /* CONFIG_NS16550 */
+/** Initialize keyboard.
+ *
+ * Traverse OpenFirmware device tree in order to find necessary
+ * info about the keyboard device.
+ *
+ * @param node Keyboard device node.
+ *
+ */
+void kbd_init(ofw_tree_node_t *node)
+{
 #ifdef CONFIG_Z8530
-    case KBD_Z8530:
-        z8530 = (z8530_t *)
-            (hw_map(aligned_addr, offset + size) + offset);
-        indev_t *kbrdin_z8530 = z8530_init(z8530, inr, cir, cir_arg);
-        if (kbrdin_z8530)
-            kbrd_init(kbrdin_z8530);
-        /*
-         * This is the necessary evil until the userspace drivers are
-         * entirely self-sufficient.
-         */
-        sysinfo_set_item_val("kbd", NULL, true);
-        sysinfo_set_item_val("kbd.type", NULL, KBD_Z8530);
-        sysinfo_set_item_val("kbd.inr", NULL, inr);
-        sysinfo_set_item_val("kbd.address.kernel", NULL,
-            (uintptr_t) z8530);
-        sysinfo_set_item_val("kbd.address.physical", NULL, pa);
-        break;
+    kbd_z8530_init(node);
 #endif
 #ifdef CONFIG_NS16550
-    case KBD_NS16550:
-        ns16550 = (ns16550_t *)
-           (hw_map(aligned_addr, offset + size) + offset);
-        indev_t *kbrdin_ns16550 = ns16550_init(ns16550, inr, cir, cir_arg);
-        if (kbrdin_ns16550)
-            kbrd_init(kbrdin_ns16550);
-        /*
-         * This is the necessary evil until the userspace driver is
-         * entirely self-sufficient.
-         */
-        sysinfo_set_item_val("kbd", NULL, true);
-        sysinfo_set_item_val("kbd.type", NULL, KBD_NS16550);
-        sysinfo_set_item_val("kbd.inr", NULL, inr);
-        sysinfo_set_item_val("kbd.address.kernel", NULL,
-            (uintptr_t) ns16550);
-        sysinfo_set_item_val("kbd.address.physical", NULL, pa);
-        break;
+    kbd_ns16550_init(node);
 #endif
-    default:
-        printf("Kernel is not compiled with the necessary keyboard "
-            "driver this machine requires.\n");
-    }
 }
-#endif
+#endif /* CONFIG_SUN_KBD */
 /** @}
  */

 /branches/dd/kernel/arch/sparc64/src/drivers/sgcn.c
 ,9 → 101,6
 /** Returns a pointer to the console buffer header. */
 #define SGCN_BUFFER_HEADER  (SGCN_BUFFER(sgcn_buffer_header_t, 0))
-/** defined in drivers/kbd.c */
-extern kbd_type_t kbd_type;
 /** starting address of SRAM, will be set by the init_sram_begin function */
 static uintptr_t sram_begin;
 ,12 → 134,6
     .write = sgcn_putchar
 };
-/** SGCN input device operations */
-static indev_operations_t sgcnin_ops = {
-    .poll = NULL
-};
-static indev_t sgcnin;      /**< SGCN input device. */
 static outdev_t sgcnout;    /**< SGCN output device. */
 /**
 ,7 → 279,7
  */
 void sgcn_grab(void)
 {
-    kbd_disabled = true;
+    kbd_disabled = false;
 }
 /**
 ,7 → 295,7
  * there are some unread characters in the input queue. If so, it picks them up
  * and sends them to the upper layers of HelenOS.
  */
-static void sgcn_poll()
+static void sgcn_poll(sgcn_instance_t *instance)
 {
     uint32_t begin = SGCN_BUFFER_HEADER->in_begin;
     uint32_t end = SGCN_BUFFER_HEADER->in_end;
 ,13 → 313,12
     volatile uint32_t *in_rdptr_ptr = &(SGCN_BUFFER_HEADER->in_rdptr);
     while (*in_rdptr_ptr != *in_wrptr_ptr) {
         buf_ptr = (volatile char *)
             SGCN_BUFFER(char, SGCN_BUFFER_HEADER->in_rdptr);
         char c = *buf_ptr;
         *in_rdptr_ptr = (((*in_rdptr_ptr) - begin + 1) % size) + begin;
-        indev_push_character(&sgcnin, c);
+        indev_push_character(instance->srlnin, c);
     }
     spinlock_unlock(&sgcn_input_lock);
 ,11 → 327,10
 /**
  * Polling thread function.
  */
-static void kkbdpoll(void *arg) {
+static void ksgcnpoll(void *instance) {
     while (1) {
-        if (!silent) {
-            sgcn_poll();
-        }
+        if (!silent)
+            sgcn_poll(instance);
         thread_usleep(POLL_INTERVAL);
     }
 }
 ,23 → 338,36
 /**
  * A public function which initializes input from the Serengeti console.
  */
-indev_t *sgcnin_init(void)
+sgcn_instance_t *sgcnin_init(void)
 {
     sgcn_buffer_begin_init();
+    sgcn_instance_t *instance =
+        malloc(sizeof(sgcn_instance_t), FRAME_ATOMIC);
+    if (instance) {
+        instance->srlnin = NULL;
+        instance->thread = thread_create(ksgcnpoll, instance, TASK, 0,
+            "ksgcnpoll", true);
+        if (!instance->thread) {
+            free(instance);
+            return NULL;
+        }
+    }
+    return instance;
+}
-    kbd_type = KBD_SGCN;
+void sgcnin_wire(sgcn_instance_t *instance, indev_t *srlnin)
+{
+    ASSERT(instance);
+    ASSERT(srlnin);
+    instance->srlnin = srlnin;
+    thread_ready(instance->thread);
     sysinfo_set_item_val("kbd", NULL, true);
-    sysinfo_set_item_val("kbd.type", NULL, KBD_SGCN);
-    thread_t *t = thread_create(kkbdpoll, NULL, TASK, 0, "kkbdpoll", true);
-    if (!t)
-        panic("Cannot create kkbdpoll.");
-    thread_ready(t);
-    indev_initialize("sgcnin", &sgcnin, &sgcnin_ops);
-    return &sgcnin;
 }
 /**

 /branches/dd/kernel/arch/sparc64/src/start.S
 ,7 → 294,7
     /* Not reached. */
 :
-    ba 0b
+    ba %xcc, 0b
     nop
 ,7 → 352,7
 #endif
 :
-    ba 0b
+    ba %xcc, 0b
     nop

 /branches/dd/kernel/arch/ia64/include/arch.h
 ,7 → 26,7
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup ia64
+/** @addtogroup ia64
  * @{
  */
 /** @file
 ,7 → 37,7
 #define LOADED_PROG_STACK_PAGES_NO 2
-#include <arch/ski/ski.h>
+#include <arch/drivers/ski.h>
 extern void arch_pre_main(void);

 /branches/dd/kernel/arch/ia64/include/drivers/ski.h
 ,0 → 1,56
+/*
+ * Copyright (c) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup ia64
+ * @{
+ */
+/** @file
+ */
+#ifndef KERN_ia64_SKI_H_
+#define KERN_ia64_SKI_H_
+#include <console/chardev.h>
+#include <proc/thread.h>
+typedef struct {
+    thread_t *thread;
+    indev_t *srlnin;
+} ski_instance_t;
+extern void skiout_init(void);
+extern ski_instance_t *skiin_init(void);
+extern void skiin_wire(ski_instance_t *, indev_t *);
+extern void ski_kbd_grab(void);
+extern void ski_kbd_release(void);
+#endif
+/** @}
+ */
 Property changes:
 Added: svn:mergeinfo

 /branches/dd/kernel/arch/ia64/Makefile.inc
 ,8 → 64,7
     arch/$(KARCH)/src/drivers/it.c
 ifeq ($(MACHINE),ski)
-    ARCH_SOURCES += arch/$(KARCH)/src/ski/ski.c
-    DEFS += -DSKI
+    ARCH_SOURCES += arch/$(KARCH)/src/drivers/ski.c
     BFD = binary
 endif

 /branches/dd/kernel/arch/ia64/src/smp/smp.c
 ,7 → 33,7
  */
 #include <arch.h>
-#include <arch/ski/ski.h>
+#include <arch/drivers/ski.h>
 #include <arch/drivers/it.h>
 #include <arch/interrupt.h>
 #include <arch/barrier.h>

 /branches/dd/kernel/arch/ia64/src/ia64.c
 ,7 → 33,7
  */
 #include <arch.h>
-#include <arch/ski/ski.h>
+#include <arch/drivers/ski.h>
 #include <arch/drivers/it.h>
 #include <arch/interrupt.h>
 #include <arch/barrier.h>
 ,11 → 148,17
 void arch_post_smp_init(void)
 {
-#ifdef SKI
-    indev_t *in;
-    in = skiin_init();
-    if (in)
-        srln_init(in);
+#ifdef MACHINE_ski
+    ski_instance_t *ski_instance = skiin_init();
+    if (ski_instance) {
+        srln_instance_t *srln_instance = srln_init();
+        if (srln_instance) {
+            indev_t *sink = stdin_wire();
+            indev_t *srln = srln_wire(srln_instance, sink);
+            skiin_wire(ski_instance, srln);
+        }
+    }
     skiout_init();
 #endif
 ,10 → 167,16
 #endif
 #ifdef CONFIG_NS16550
-    indev_t *kbrdin_ns16550
+    ns16550_instance_t *ns16550_instance
         = ns16550_init((ns16550_t *) NS16550_BASE, NS16550_IRQ, NULL, NULL);
-    if (kbrdin_ns16550)
-        srln_init(kbrdin_ns16550);
+    if (ns16550_instance) {
+        srln_instance_t *srln_instance = srln_init();
+        if (srln_instance) {
+            indev_t *sink = stdin_wire();
+            indev_t *srln = srln_wire(srln_instance, sink);
+            ns16550_wire(ns16550_instance, srln);
+        }
+    }
     sysinfo_set_item_val("kbd", NULL, true);
     sysinfo_set_item_val("kbd.inr", NULL, NS16550_IRQ);
 ,9 → 188,15
 #endif
 #ifdef CONFIG_I8042
-    indev_t *kbrdin_i8042 = i8042_init((i8042_t *) I8042_BASE, IRQ_KBD);
-    if (kbrdin_i8042)
-        kbrd_init(kbrdin_i8042);
+    i8042_instance_t *i8042_instance = i8042_init((i8042_t *) I8042_BASE, IRQ_KBD);
+    if (i8042_instance) {
+        kbrd_instance_t *kbrd_instance = kbrd_init();
+        if (kbrd_instance) {
+            indev_t *sink = stdin_wire();
+            indev_t *kbrd = kbrd_wire(kbrd_instance, sink);
+            i8042_wire(i8042_instance, kbrd);
+        }
+    }
     sysinfo_set_item_val("kbd", NULL, true);
     sysinfo_set_item_val("kbd.inr", NULL, IRQ_KBD);
 ,7 → 256,7
  */
 void arch_grab_console(void)
 {
-#ifdef SKI
+#ifdef MACHINE_ski
     ski_kbd_grab();
 #endif
 }
 ,7 → 266,7
  */
 void arch_release_console(void)
 {
-#ifdef SKI
+#ifdef MACHINE_ski
     ski_kbd_release();
 #endif
 }

 /branches/dd/kernel/arch/ia64/src/drivers/ski.c
 ,0 → 1,246
+/*
+ * Copyright (c) 2005 Jakub Jermar
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/** @addtogroup ia64
+ * @{
+ */
+/** @file
+ */
+#include <arch/drivers/ski.h>
+#include <console/console.h>
+#include <console/chardev.h>
+#include <sysinfo/sysinfo.h>
+#include <arch/types.h>
+#include <proc/thread.h>
+#include <synch/spinlock.h>
+#include <arch/asm.h>
+#include <arch/drivers/kbd.h>
+#include <string.h>
+#include <arch.h>
+enum {
+    /** Interval between polling in microseconds */
+    POLL_INTERVAL =  10000,  /* 0.01 s */
+    /** Max. number of characters to pull out at a time */
+    POLL_LIMIT    =     30,
+    SKI_INIT_CONSOLE  = 20,
+    SKI_GETCHAR       = 21,
+    SKI_PUTCHAR       = 31
+};
+static void ski_putchar(outdev_t *, const wchar_t, bool);
+static outdev_operations_t skiout_ops = {
+    .write = ski_putchar
+};
+static outdev_t skiout;            /**< Ski output device. */
+static bool initialized = false;
+static bool kbd_disabled = false;
+/** Initialize debug console
+ *
+ * Issue SSC (Simulator System Call) to
+ * to open debug console.
+ *
+ */
+static void ski_init(void)
+{
+    if (initialized)
+        return;
+    asm volatile (
+        "mov r15 = %0\n"
+        "break 0x80000\n"
+        :
+        : "i" (SKI_INIT_CONSOLE)
+        : "r15", "r8"
+    );
+    initialized = true;
+}
+static void ski_do_putchar(const wchar_t ch)
+{
+    asm volatile (
+        "mov r15 = %[cmd]\n"
+        "mov r32 = %[ch]\n"   /* r32 is in0 */
+        "break 0x80000\n"     /* modifies r8 */
+        :
+        : [cmd] "i" (SKI_PUTCHAR), [ch] "r" (ch)
+        : "r15", "in0", "r8"
+    );
+}
+/** Display character on debug console
+ *
+ * Use SSC (Simulator System Call) to
+ * display character on debug console.
+ *
+ * @param dev    Character device.
+ * @param ch     Character to be printed.
+ * @param silent Whether the output should be silenced.
+ *
+ */
+static void ski_putchar(outdev_t *dev, const wchar_t ch, bool silent)
+{
+    if (!silent) {
+        if (ascii_check(ch)) {
+            if (ch == '\n')
+                ski_do_putchar('\r');
+            ski_do_putchar(ch);
+        } else
+            ski_do_putchar(U_SPECIAL);
+    }
+}
+void skiout_init(void)
+{
+    ski_init();
+    outdev_initialize("skiout", &skiout, &skiout_ops);
+    stdout = &skiout;
+    sysinfo_set_item_val("fb", NULL, false);
+}
+/** Ask debug console if a key was pressed.
+ *
+ * Use SSC (Simulator System Call) to
+ * get character from debug console.
+ *
+ * This call is non-blocking.
+ *
+ * @return ASCII code of pressed key or 0 if no key pressed.
+ *
+ */
+static wchar_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 (wchar_t) ch;
+}
+/** Ask keyboard if a key was pressed.
+ *
+ * If so, it will repeat and pull up to POLL_LIMIT characters.
+ */
+static void poll_keyboard(ski_instance_t *instance)
+{
+    wchar_t ch;
+    int count;
+    if (kbd_disabled)
+        return;
+    count = POLL_LIMIT;
+    while (count > 0) {
+        ch = ski_getchar();
+        if (ch == '\0')
+            break;
+        indev_push_character(instance->srlnin, ch);
+        --count;
+    }
+}
+/** Kernel thread for polling keyboard. */
+static void kskipoll(void *arg)
+{
+    ski_instance_t *instance = (ski_instance_t *) arg;
+    while (true) {
+        if (!silent)
+            poll_keyboard(instance);
+        thread_usleep(POLL_INTERVAL);
+    }
+}
+ski_instance_t *skiin_init(void)
+{
+    ski_init();
+    ski_instance_t *instance =
+        malloc(sizeof(ski_instance_t), FRAME_ATOMIC);
+    if (instance) {
+        instance->thread = thread_create(kskipoll, instance, TASK, 0,
+            "kskipoll", true);
+        if (!instance->thread) {
+            free(instance);
+            return NULL;
+        }
+        instance->srlnin = NULL;
+    }
+    return instance;
+}
+void skiin_wire(ski_instance_t *instance, indev_t *srlnin)
+{
+    ASSERT(instance);
+    ASSERT(srlnin);
+    instance->srlnin = srlnin;
+    thread_ready(instance->thread);
+    sysinfo_set_item_val("kbd", NULL, true);
+    sysinfo_set_item_val("kbd.type", NULL, KBD_SKI);
+}
+void ski_kbd_grab(void)
+{
+    kbd_disabled = false;
+}
+void ski_kbd_release(void)
+{
+    kbd_disabled = true;
+}
+/** @}
+ */
 Property changes:
 Added: svn:mergeinfo

/branches/dd/kernel/arch/arm32/Makefile.inc
51,7 → 51,6
arch/$(KARCH)/src/cpu/cpu.c \
arch/$(KARCH)/src/ddi/ddi.c \
arch/$(KARCH)/src/interrupt.c \
arch/$(KARCH)/src/console.c \
arch/$(KARCH)/src/exception.c \
arch/$(KARCH)/src/userspace.c \
arch/$(KARCH)/src/mm/as.c \

 /branches/dd/kernel/arch/arm32/src/arm32.c
 ,7 → 35,6
 #include <arch.h>
 #include <config.h>
-#include <arch/console.h>
 #include <genarch/fb/fb.h>
 #include <genarch/fb/visuals.h>
 #include <genarch/drivers/dsrln/dsrlnin.h>
 ,6 → 41,7
 #include <genarch/drivers/dsrln/dsrlnout.h>
 #include <genarch/srln/srln.h>
 #include <sysinfo/sysinfo.h>
+#include <console/console.h>
 #include <ddi/irq.h>
 #include <arch/drivers/gxemul.h>
 #include <print.h>
 ,11 → 129,18
 #ifdef CONFIG_ARM_KBD
     /*
      * Initialize the GXemul keyboard port. Then initialize the serial line
-     * module and connect it to the GXemul keyboard. Enable keyboard interrupts.
+     * module and connect it to the GXemul keyboard.
      */
-    indev_t *kbrdin = dsrlnin_init((dsrlnin_t *) gxemul_kbd, GXEMUL_KBD_IRQ);
-    if (kbrdin)
-        srln_init(kbrdin);
+    dsrlnin_instance_t *dsrlnin_instance
+        = dsrlnin_init((dsrlnin_t *) gxemul_kbd, GXEMUL_KBD_IRQ);
+    if (dsrlnin_instance) {
+        srln_instance_t *srln_instance = srln_init();
+        if (srln_instance) {
+            indev_t *sink = stdin_wire();
+            indev_t *srln = srln_wire(srln_instance, sink);
+            dsrlnin_wire(dsrlnin_instance, srln);
+        }
+    }
     /*
      * This is the necessary evil until the userspace driver is entirely
 ,5 → 208,18
     return addr;
 }
+/** Acquire console back for kernel. */
+void arch_grab_console(void)
+{
+#ifdef CONFIG_FB
+    fb_redraw();
+#endif
+}
+/** Return console to userspace. */
+void arch_release_console(void)
+{
+}
 /** @}
  */

 /branches/dd/kernel/arch/ppc32/include/drivers/pic.h
 ,7 → 26,7
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup ppc32
+/** @addtogroup ppc32
  * @{
  */
 /** @file
 ,6 → 36,7
 #define KERN_ppc32_PIC_H_
 #include <arch/types.h>
+#include <ddi/irq.h>
 #define PIC_PENDING_LOW    8
 #define PIC_PENDING_HIGH   4
 ,11 → 45,11
 #define PIC_ACK_LOW        10
 #define PIC_ACK_HIGH       6
-void pic_init(uintptr_t base, size_t size);
-void pic_enable_interrupt(int intnum);
-void pic_disable_interrupt(int intnum);
-void pic_ack_interrupt(int intnum);
-int pic_get_pending(void);
+extern void pic_init(uintptr_t base, size_t size, cir_t *cir, void **cir_arg);
+extern void pic_enable_interrupt(inr_t intnum);
+extern void pic_disable_interrupt(inr_t intnum);
+extern void pic_ack_interrupt(void *arg, inr_t intnum);
+extern int pic_get_pending(void);
 #endif

/branches/dd/kernel/arch/ppc32/Makefile.inc
54,7 → 54,6
arch/$(KARCH)/src/cpu/cpu.c \
arch/$(KARCH)/src/proc/scheduler.c \
arch/$(KARCH)/src/ddi/ddi.c \
arch/$(KARCH)/src/drivers/cuda.c \
arch/$(KARCH)/src/mm/as.c \
arch/$(KARCH)/src/mm/frame.c \
arch/$(KARCH)/src/mm/page.c \

 /branches/dd/kernel/arch/ppc32/src/ppc32.c
 ,7 → 35,7
 #include <config.h>
 #include <arch.h>
 #include <arch/boot/boot.h>
-#include <arch/drivers/cuda.h>
+#include <genarch/drivers/via-cuda/cuda.h>
 #include <arch/interrupt.h>
 #include <genarch/fb/fb.h>
 #include <genarch/fb/visuals.h>
 ,10 → 44,12
 #include <console/console.h>
 #include <ddi/irq.h>
 #include <arch/drivers/pic.h>
+#include <align.h>
 #include <macros.h>
 #include <string.h>
 #define IRQ_COUNT  64
+#define IRQ_CUDA   10
 bootinfo_t bootinfo;
 ,10 → 119,27
         if (bootinfo.macio.addr) {
             /* Initialize PIC */
-            pic_init(bootinfo.macio.addr, PAGE_SIZE);
+            cir_t cir;
+            void *cir_arg;
+            pic_init(bootinfo.macio.addr, PAGE_SIZE, &cir, &cir_arg);
+#ifdef CONFIG_VIA_CUDA
+            uintptr_t pa = bootinfo.macio.addr + 0x16000;
+            uintptr_t aligned_addr = ALIGN_DOWN(pa, PAGE_SIZE);
+            size_t offset = pa - aligned_addr;
+            size_t size = 2 * PAGE_SIZE;
+            cuda_t *cuda = (cuda_t *)
+                (hw_map(aligned_addr, offset + size) + offset);
             /* Initialize I/O controller */
-            cuda_init(bootinfo.macio.addr + 0x16000, 2 * PAGE_SIZE);
+            cuda_instance_t *cuda_instance =
+                cuda_init(cuda, IRQ_CUDA, cir, cir_arg);
+            if (cuda_instance) {
+                indev_t *sink = stdin_wire();
+                cuda_wire(cuda_instance, sink);
+            }
+#endif
         }
         /* Merge all zones to 1 big zone */
 ,5 → 205,11
     return addr;
 }
+void arch_reboot(void)
+{
+    // TODO
+    while (1);
+}
 /** @}
  */

 /branches/dd/kernel/arch/ppc32/src/dummy.s
 ,6 → 30,7
 .global asm_delay_loop
 .global sys_tls_set
+.global cpu_halt
 sys_tls_set:
     b sys_tls_set
 ,3 → 37,6
 asm_delay_loop:
     blr
+cpu_halt:
+    b cpu_halt

 /branches/dd/kernel/arch/ppc32/src/interrupt.c
 ,7 → 60,6
     int inum;
     while ((inum = pic_get_pending()) != -1) {
-        bool ack = false;
         irq_t *irq = irq_dispatch_and_lock(inum);
         if (irq) {
             /*
 ,11 → 68,17
             if (irq->preack) {
                 /* Acknowledge the interrupt before processing */
-                pic_ack_interrupt(inum);
-                ack = true;
+                if (irq->cir)
+                    irq->cir(irq->cir_arg, irq->inr);
             }
             irq->handler(irq);
+            if (!irq->preack) {
+                if (irq->cir)
+                    irq->cir(irq->cir_arg, irq->inr);
+            }
             spinlock_unlock(&irq->lock);
         } else {
             /*
 ,9 → 88,6
             printf("cpu%u: spurious interrupt (inum=%d)\n", CPU->id, inum);
 #endif
         }
-        if (!ack)
-            pic_ack_interrupt(inum);
     }
 }

 /branches/dd/kernel/arch/ppc32/src/drivers/pic.c
 ,7 → 26,7
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-/** @addtogroup ppc32
+/** @addtogroup ppc32
  * @{
  */
 /** @file
 ,12 → 40,14
 static volatile uint32_t *pic = NULL;
-void pic_init(uintptr_t base, size_t size)
+void pic_init(uintptr_t base, size_t size, cir_t *cir, void **cir_arg)
 {
     pic = (uint32_t *) hw_map(base, size);
+    *cir = pic_ack_interrupt;
+    *cir_arg = NULL;
 }
-void pic_enable_interrupt(int intnum)
+void pic_enable_interrupt(inr_t intnum)
 {
     if (pic) {
         if (intnum < 32)
 ,7 → 58,7
 }
-void pic_disable_interrupt(int intnum)
+void pic_disable_interrupt(inr_t intnum)
 {
     if (pic) {
         if (intnum < 32)
 ,7 → 68,7
     }
 }
-void pic_ack_interrupt(int intnum)
+void pic_ack_interrupt(void *arg, inr_t intnum)
 {
     if (pic) {
         if (intnum < 32)

 /branches/dd/kernel/arch/amd64/include/atomic.h
 ,9 → 115,7
     preemption_disable();
     asm volatile (
         "0:\n"
-#ifdef CONFIG_HT
         "pause\n"
-#endif
         "mov %[count], %[tmp]\n"
         "testq %[tmp], %[tmp]\n"
         "jnz 0b\n"       /* lightweight looping on locked spinlock */

 /branches/dd/kernel/arch/amd64/src/amd64.c
 ,10 → 197,15
      * Initialize the i8042 controller. Then initialize the keyboard
      * module and connect it to i8042. Enable keyboard interrupts.
      */
-    indev_t *kbrdin = i8042_init((i8042_t *) I8042_BASE, IRQ_KBD);
-    if (kbrdin) {
-        kbrd_init(kbrdin);
-        trap_virtual_enable_irqs(1 << IRQ_KBD);
+    i8042_instance_t *i8042_instance = i8042_init((i8042_t *) I8042_BASE, IRQ_KBD);
+    if (i8042_instance) {
+        kbrd_instance_t *kbrd_instance = kbrd_init();
+        if (kbrd_instance) {
+            indev_t *sink = stdin_wire();
+            indev_t *kbrd = kbrd_wire(kbrd_instance, sink);
+            i8042_wire(i8042_instance, kbrd);
+            trap_virtual_enable_irqs(1 << IRQ_KBD);
+        }
     }
     /*

 /branches/dd/kernel/arch/mips32/include/elf.h
 ,9 → 35,11
 #ifndef KERN_mips32_ELF_H_
 #define KERN_mips32_ELF_H_
+#include <byteorder.h>
 #define ELF_MACHINE     EM_MIPS
-#ifdef BIG_ENDIAN
+#ifdef ARCH_IS_BIG_ENDIAN
 #  define ELF_DATA_ENCODING ELFDATA2MSB
 #else
 #  define ELF_DATA_ENCODING ELFDATA2LSB

/branches/dd/kernel/arch/mips32/Makefile.inc
60,7 → 60,6
arch/$(KARCH)/src/context.S \
arch/$(KARCH)/src/panic.S \
arch/$(KARCH)/src/mips32.c \
arch/$(KARCH)/src/console.c \
arch/$(KARCH)/src/asm.S \
arch/$(KARCH)/src/exception.c \
arch/$(KARCH)/src/interrupt.c \

 /branches/dd/kernel/arch/mips32/src/mips32.c
 ,16 → 36,14
 #include <arch/cp0.h>
 #include <arch/exception.h>
 #include <mm/as.h>
 #include <userspace.h>
-#include <arch/console.h>
 #include <memstr.h>
 #include <proc/thread.h>
 #include <proc/uarg.h>
 #include <print.h>
+#include <console/console.h>
 #include <syscall/syscall.h>
 #include <sysinfo/sysinfo.h>
 #include <arch/interrupt.h>
 #include <console/chardev.h>
 #include <arch/barrier.h>
 ,7 → 57,6
 #include <config.h>
 #include <string.h>
 #include <arch/drivers/msim.h>
 #include <arch/asm/regname.h>
 /* Size of the code jumping to the exception handler code
 ,10 → 166,16
      * Initialize the msim/GXemul keyboard port. Then initialize the serial line
      * module and connect it to the msim/GXemul keyboard. Enable keyboard interrupts.
      */
-    indev_t *kbrdin = dsrlnin_init((dsrlnin_t *) MSIM_KBD_ADDRESS, MSIM_KBD_IRQ);
-    if (kbrdin) {
-        srln_init(kbrdin);
-        cp0_unmask_int(MSIM_KBD_IRQ);
+    dsrlnin_instance_t *dsrlnin_instance
+        = dsrlnin_init((dsrlnin_t *) MSIM_KBD_ADDRESS, MSIM_KBD_IRQ);
+    if (dsrlnin_instance) {
+        srln_instance_t *srln_instance = srln_init();
+        if (srln_instance) {
+            indev_t *sink = stdin_wire();
+            indev_t *srln = srln_wire(srln_instance, sink);
+            dsrlnin_wire(dsrlnin_instance, srln);
+            cp0_unmask_int(MSIM_KBD_IRQ);
+        }
     }
     /*
 ,5 → 251,19
     return addr;
 }
+void arch_grab_console(void)
+{
+#ifdef CONFIG_FB
+    fb_redraw();
+#endif
+}
+/** Return console to userspace
+ *
+ */
+void arch_release_console(void)
+{
+}
 /** @}
  */

 /branches/dd/kernel/arch/ia32/include/atomic.h
 ,9 → 114,7
     preemption_disable();
     asm volatile (
         "0:\n"
-#ifdef CONFIG_HT
         "pause\n"        /* Pentium 4's HT love this instruction */
-#endif
         "mov %[count], %[tmp]\n"
         "testl %[tmp], %[tmp]\n"
         "jnz 0b\n"       /* lightweight looping on locked spinlock */

 /branches/dd/kernel/arch/ia32/src/ia32.c
 ,7 → 80,7
 void arch_pre_main(uint32_t signature, const multiboot_info_t *mi)
 {
     /* Parse multiboot information obtained from the bootloader. */
-    multiboot_info_parse(signature, mi);
+    multiboot_info_parse(signature, mi);
 #ifdef CONFIG_SMP
     /* Copy AP bootstrap routines below 1 MB. */
 ,10 → 155,15
      * Initialize the i8042 controller. Then initialize the keyboard
      * module and connect it to i8042. Enable keyboard interrupts.
      */
-    indev_t *kbrdin = i8042_init((i8042_t *) I8042_BASE, IRQ_KBD);
-    if (kbrdin) {
-        kbrd_init(kbrdin);
-        trap_virtual_enable_irqs(1 << IRQ_KBD);
+    i8042_instance_t *i8042_instance = i8042_init((i8042_t *) I8042_BASE, IRQ_KBD);
+    if (i8042_instance) {
+        kbrd_instance_t *kbrd_instance = kbrd_init();
+        if (kbrd_instance) {
+            indev_t *sink = stdin_wire();
+            indev_t *kbrd = kbrd_wire(kbrd_instance, sink);
+            i8042_wire(i8042_instance, kbrd);
+            trap_virtual_enable_irqs(1 << IRQ_KBD);
+        }
     }
     /*

 /branches/dd/kernel/arch/ia32/src/atomic.S
 ,9 → 42,7
     movl 12(%esp),%ebx
 :
-    #ifdef CONFIG_HT
     pause           # Pentium 4's with HT love this instruction
-    #endif
     movl (%ebx),%eax
     testl %eax,%eax
     jnz 0b          # lightweight looping while it is locked

Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 4419 → Rev 4420