Changeset c2417bc in mainline for kernel/genarch/src/kbrd/kbrd.c

Timestamp:

2009-04-21T12:46:26Z (15 years ago)

Author:

Martin Decky <martin@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

f2d2c7ba

Parents:

44b7783

Message:

change the way how input devices are wired together according to ticket #44
(also the proposal ​http://lists.modry.cz/cgi-bin/private/helenos-devel/2009-March/002507.html)

File:

• kernel/genarch/src/kbrd/kbrd.c (modified) (7 diffs)

kernel/genarch/src/kbrd/kbrd.c

@@ -60 +60 @@
 #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.
@@ -74 +68 @@
  * @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);
 }
 
@@ -99 +95 @@
  * @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;
@@ -105 +101 @@
         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:
@@ -118 +115 @@
         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))
@@ -126 +123 @@
                 
                 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)
@@ -145 +143 @@
                 
                 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;
 }