From 0471b0eeea5ea30883c776dd53275ec6b8454ca7 Mon Sep 17 00:00:00 2001
From: Minep <zelong56@gmail.com>
Date: Sun, 1 May 2022 00:31:02 +0100
Subject: [PATCH] Implement shift+<key> support, and ... Modifier state are now
 avaliable in key event state. Bounded buffer for upper layer polls the key
 event. A simple keyboard input demo added in k_main.c Add a mutex lock on
 senstive region. Fix ps/2 io bugs, LEDs should works now.

---
 lunaix-os/.vscode/c_cpp_properties.json       |   3 +-
 lunaix-os/includes/lunaix/keyboard.h          |  37 +++-
 lunaix-os/includes/lunaix/peripheral/ps2kbd.h |  53 +++---
 lunaix-os/kernel/k_main.c                     |  16 +-
 lunaix-os/kernel/peripheral/ps2kbd.c          | 160 +++++++++++++-----
 lunaix-os/kernel/tty/tty.c                    |   4 +
 lunaix-os/makefile                            |   2 +-
 7 files changed, 203 insertions(+), 72 deletions(-)

diff --git a/lunaix-os/.vscode/c_cpp_properties.json b/lunaix-os/.vscode/c_cpp_properties.json
index dd47757..f069ef5 100644
--- a/lunaix-os/.vscode/c_cpp_properties.json
+++ b/lunaix-os/.vscode/c_cpp_properties.json
@@ -13,7 +13,8 @@
             "defines": [],
             "compilerPath": "${HOME}/opt/cross-compiler/bin/i686-elf-gcc",
             "cStandard": "gnu99",
-            "intelliSenseMode": "gcc-x86"
+            "intelliSenseMode": "gcc-x86",
+            "configurationProvider": "ms-vscode.makefile-tools"
         }
     ],
     "version": 4
diff --git a/lunaix-os/includes/lunaix/keyboard.h b/lunaix-os/includes/lunaix/keyboard.h
index f573316..c439b6f 100644
--- a/lunaix-os/includes/lunaix/keyboard.h
+++ b/lunaix-os/includes/lunaix/keyboard.h
@@ -7,16 +7,19 @@
 // key[0:7] = sequence
 // key[8:15] = category
 //   0x0: ASCII codes
-//   0x1: Function keys
-//   0x2: keypad keys
+//   0x1: keypad keys
+//   0x2: Function keys
 //   0x3: Cursor keys (arrow keys)
 //   0x4: Modifier keys
 //   0xff: Other keys (Un-categorized)
 
-typedef unsigned short kbd_keycode;
+typedef unsigned short kbd_keycode_t;
+typedef unsigned short kbd_kstate_t;
+#include <lunaix/clock.h>
 
-#define FN_KEY  0x0100
-#define KEYPAD  0x0200
+
+#define KEYPAD  0x0100
+#define FN_KEY  0x0200
 #define CURSOR  0x0300
 #define MODIFR  0x0400
 #define OTHERS  0xff00
@@ -69,4 +72,28 @@ typedef unsigned short kbd_keycode;
 #define KEY_LALT         (0x4 | MODIFR)
 #define KEY_RALT         (0x5 | MODIFR)
 
+#define KBD_KEY_FRELEASED 0x0
+#define KBD_KEY_FPRESSED 0x1
+#define KBD_KEY_FSCRLLKED 0x2
+#define KBD_KEY_FNUMBLKED 0x4
+#define KBD_KEY_FCAPSLKED 0x8
+
+#define KBD_KEY_FLSHIFT_HELD 0x10
+#define KBD_KEY_FRSHIFT_HELD 0x20
+#define KBD_KEY_FLCTRL_HELD 0x40
+#define KBD_KEY_FRCTRL_HELD 0x80
+#define KBD_KEY_FLALT_HELD 0x100
+#define KBD_KEY_FRALT_HELD 0x200
+
+typedef unsigned char kbd_scancode_t;
+
+struct kdb_keyinfo_pkt {
+    kbd_scancode_t scancode;
+    kbd_keycode_t keycode;
+    kbd_kstate_t state;
+    time_t timestamp;
+};
+
+struct kdb_keyinfo_pkt* kbd_try_read_one();
+
 #endif /* __LUNAIX_KEYBOARD_H */
diff --git a/lunaix-os/includes/lunaix/peripheral/ps2kbd.h b/lunaix-os/includes/lunaix/peripheral/ps2kbd.h
index ca49cb7..a63ffdc 100644
--- a/lunaix-os/includes/lunaix/peripheral/ps2kbd.h
+++ b/lunaix-os/includes/lunaix/peripheral/ps2kbd.h
@@ -3,11 +3,11 @@
 
 #include <hal/io.h>
 #include <lunaix/keyboard.h>
-#include <lunaix/clock.h>
 
-#define PS2_PORT_DATA 0x60
-#define PS2_PORT_STATUS 0x64
-#define PS2_PORT_CMDREG 0x64
+#define PS2_PORT_ENC_DATA 0x60
+#define PS2_PORT_ENC_CMDREG 0x60
+#define PS2_PORT_CTRL_STATUS 0x64
+#define PS2_PORT_CTRL_CMDREG 0x64
 
 #define PS2_STATUS_OFULL   0x1
 #define PS2_STATUS_IFULL   0x2
@@ -48,21 +48,6 @@
 #define PS2_NO_ARG 0xff00
 
 
-#define KBD_KEY_RELEASED 0x0
-#define KBD_KEY_PRESSED 0x1
-#define KBD_KEY_SCRLLKED 0x2
-#define KBD_KEY_NUMBLKED 0x4
-#define KBD_KEY_CAPSLKED 0x8
-
-typedef unsigned char kbd_kstate_t;
-
-struct kdb_keyinfo_pkt {
-    char key;
-    kbd_keycode code;
-    kbd_kstate_t state;
-    time_t timestamp;
-};
-
 struct ps2_cmd {
     char cmd;
     char arg;
@@ -70,7 +55,8 @@ struct ps2_cmd {
 
 struct ps2_kbd_state {
     char state;
-    kbd_keycode* translation_table;
+    volatile char masked;
+    kbd_keycode_t* translation_table;
     kbd_kstate_t key_state;
 };
 
@@ -78,30 +64,47 @@ struct ps2_cmd_queue {
     struct ps2_cmd cmd_queue[PS2_CMD_QUEUE_SIZE];
     int queue_ptr;
     int queue_len;
+    // FIXME: replace lock with something specialized.
+    volatile char lock;
 };
 
 struct ps2_key_buffer {
-    struct kdb_keyinfo_pkt key_buff[PS2_KBD_RECV_BUFFER_SIZE];
-    int buffer_ptr;
-    // We don't bother whether the buff is full or not, just override.
+    struct kdb_keyinfo_pkt buffer[PS2_KBD_RECV_BUFFER_SIZE];
+    int read_ptr;
+    int buffered_len;
+    // FIXME: replace lock with something specialized.
+    volatile char lock;
 };
 
 /**
- * @brief 向PS/2控制器发送指令并等待返回代码。注意，对于没有返回代码的命令请使用`ps2_post_cmd`，否则会造成死锁。
+ * @brief 向PS/2控制器的控制端口(0x64)发送指令并等待返回代码。
+ * 注意，对于没有返回代码的命令请使用`ps2_post_cmd`，否则会造成死锁。
+ * 通过调用该方法向控制器发送指令，请区别 ps2_issue_dev_cmd
  * 
  * @param cmd 
  * @param args
  */
 static uint8_t ps2_issue_cmd(char cmd, uint16_t arg);
 
+/**
+ * @brief 向PS/2控制器的编码器端口(0x60)发送指令并等待返回代码。
+ * 注意，对于没有返回代码的命令请使用`ps2_post_cmd`，否则会造成死锁。
+ * 通过调用该方法向PS/2设备发送指令，请区别 ps2_issue_cmd
+ * 
+ * @param cmd 
+ * @param args
+ */
+static uint8_t ps2_issue_dev_cmd(char cmd, uint16_t arg);
+
 /**
  * @brief 向PS/2控制器发送指令，不等待返回代码。
  * 
+ * @param port 端口号
  * @param cmd 
  * @param args 
  * @return char 
  */
-static void ps2_post_cmd(char cmd, uint16_t arg);
+static void ps2_post_cmd(uint8_t port, char cmd, uint16_t arg);
 
 void ps2_device_post_cmd(char cmd, char arg);
 
diff --git a/lunaix-os/kernel/k_main.c b/lunaix-os/kernel/k_main.c
index b3b1103..fe5645f 100644
--- a/lunaix-os/kernel/k_main.c
+++ b/lunaix-os/kernel/k_main.c
@@ -5,6 +5,8 @@
 #include <lunaix/spike.h>
 #include <lunaix/clock.h>
 #include <lunaix/timer.h>
+#include <lunaix/keyboard.h>
+#include <lunaix/tty/tty.h>
 #include <stdint.h>
 
 extern uint8_t __kernel_start;
@@ -51,7 +53,19 @@ _kernel_main()
     lxfree(arr);
     lxfree(big_);
 
-    timer_run_second(1, test_timer, NULL, TIMER_MODE_PERIODIC);
+    // timer_run_second(1, test_timer, NULL, TIMER_MODE_PERIODIC);
+
+    while (1)
+    {
+        struct kdb_keyinfo_pkt* keyevent = kbd_try_read_one();
+        if (!keyevent) {
+            continue;
+        }
+        if ((keyevent->state & KBD_KEY_FPRESSED) && (keyevent->keycode & 0xff00) <= KEYPAD) {
+            tty_put_char((char)(keyevent->keycode & 0x00ff));
+        }
+        lxfree(keyevent);
+    }
 
     spin();
 }
diff --git a/lunaix-os/kernel/peripheral/ps2kbd.c b/lunaix-os/kernel/peripheral/ps2kbd.c
index 4301fed..3e5a4a1 100644
--- a/lunaix-os/kernel/peripheral/ps2kbd.c
+++ b/lunaix-os/kernel/peripheral/ps2kbd.c
@@ -3,6 +3,7 @@
 #include <lunaix/timer.h>
 #include <lunaix/common.h>
 #include <lunaix/syslog.h>
+#include <lunaix/mm/kalloc.h>
 
 #include <hal/cpu.h>
 #include <hal/ioapic.h>
@@ -25,7 +26,7 @@ static struct ps2_kbd_state kbd_state;
 // 我们使用 Scancode Set 2
 
 // 大部分的扫描码（键码）
-static kbd_keycode scancode_set2[] = {
+static kbd_keycode_t scancode_set2[] = {
     0, KEY_F9, 0, KEY_F5, KEY_F3, KEY_F1, KEY_F2, KEY_F12, 0, KEY_F10, KEY_F8, KEY_F6,
     KEY_F4, KEY_HTAB, '`', 0, 0, KEY_LALT, KEY_LSHIFT, 0, KEY_LCTRL, 'q', KEY_NUM(1), 
     0, 0, 0, 'z', 's', 'a', 'w', KEY_NUM(2), 0, 0, 'c', 'x', 'd', 'e', KEY_NUM(4), KEY_NUM(3), 
@@ -39,7 +40,7 @@ static kbd_keycode scancode_set2[] = {
 };
 
 // 一些特殊的键码（以 0xe0 位前缀的）
-static kbd_keycode scancode_set2_ex[] = {
+static kbd_keycode_t scancode_set2_ex[] = {
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, KEY_RALT, 0, 0,
     KEY_RCTRL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
@@ -51,14 +52,14 @@ static kbd_keycode scancode_set2_ex[] = {
 };
 
 // 用于处理 Shift+<key> 的情况
-static kbd_keycode scancode_set2_shift[] = {
+static kbd_keycode_t scancode_set2_shift[] = {
     0, KEY_F9, 0, KEY_F5, KEY_F3, KEY_F1, KEY_F2, KEY_F12, 0, KEY_F10, KEY_F8, KEY_F6,
     KEY_F4, KEY_HTAB, '~', 0, 0, KEY_LALT, KEY_LSHIFT, 0, KEY_LCTRL, 'Q', '!', 
     0, 0, 0, 'Z', 'S', 'A', 'W', '@', 0, 0, 'C', 'X', 'D', 'E', '$', '#', 
     0, 0, KEY_SPACE, 'V', 'F', 'T', 'R', '%',
     0, 0, 'N', 'B', 'H', 'G', 'Y', '^', 0, 0, 0, 'M', 'J', 'U', '&', '*',
-    0, 0, '<', 'K', 'I', 'O', ')', '(', 0, 0, '>', '？', 'L', ':', 'P', '_', 0, 0,
-    0, '"', '{', '+', 0, 0, KEY_CAPSLK, KEY_RSHIFT, KEY_LF, '}', 0, '|', 0, 0, 0, 0, 0, 0, 0,
+    0, 0, '<', 'K', 'I', 'O', ')', '(', 0, 0, '>', '?', 'L', ':', 'P', '_', 0, 0,
+    0, '"', 0, '{', '+', 0, 0, KEY_CAPSLK, KEY_RSHIFT, KEY_LF, '}', 0, '|', 0, 0, 0, 0, 0, 0, 0,
     0, KEY_BS, 0, 0, KEY_NPAD(1), 0, KEY_NPAD(4), KEY_NPAD(7), 0, 0, 0, KEY_NPAD(0), ON_KEYPAD('.'),
     KEY_NPAD(2), KEY_NPAD(5), KEY_NPAD(6), KEY_NPAD(8), KEY_ESC, KEY_NUMSLK, KEY_F11, ON_KEYPAD('+'),
     KEY_NPAD(3), ON_KEYPAD('-'), ON_KEYPAD('*'), KEY_SCRLLK, 0, 0, 0, 0, KEY_F7
@@ -72,7 +73,9 @@ static kbd_keycode scancode_set2_shift[] = {
 void intr_ps2_kbd_handler(const isr_param* param);
 
 void ps2_device_post_cmd(char cmd, char arg) {
-    // FIXME: Need a mutex lock on this.
+    // 不需要任何的类似lock cmpxchgl的骚操作。
+    // 这条赋值表达式最多涉及一个内存引用（e.g., movl $1, (cmd_q.lock)），因此是原子的。
+    cmd_q.lock = 1;
     int index = (cmd_q.queue_ptr + cmd_q.queue_len) % PS2_CMD_QUEUE_SIZE;
     int diff = index - cmd_q.queue_ptr;
     if (diff > 0 && diff != cmd_q.queue_len) {
@@ -84,6 +87,9 @@ void ps2_device_post_cmd(char cmd, char arg) {
     container->cmd = cmd;
     container->arg = arg;
     cmd_q.queue_len++;
+
+    // 释放锁，同理。
+    cmd_q.lock = 0;
 }
 
 void ps2_kbd_init() {
@@ -99,18 +105,18 @@ void ps2_kbd_init() {
     // XXX: 是否需要使用FADT探测PS/2控制器的存在？
 
     // 1、禁用任何的PS/2设备
-    ps2_post_cmd(PS2_CMD_PORT1_DISABLE, PS2_NO_ARG);
-    ps2_post_cmd(PS2_CMD_PORT2_DISABLE, PS2_NO_ARG);
+    ps2_post_cmd(PS2_PORT_CTRL_CMDREG, PS2_CMD_PORT1_DISABLE, PS2_NO_ARG);
+    ps2_post_cmd(PS2_PORT_CTRL_CMDREG, PS2_CMD_PORT2_DISABLE, PS2_NO_ARG);
     
     // 2、清空控制器缓冲区
-    io_inb(PS2_PORT_DATA);
+    io_inb(PS2_PORT_ENC_DATA);
 
     char result;
 
     // 3、屏蔽所有PS/2设备（端口1&2）IRQ，并且禁用键盘键码转换功能
     result = ps2_issue_cmd(PS2_CMD_READ_CFG, PS2_NO_ARG);
     result = result & ~(PS2_CFG_P1INT | PS2_CFG_P2INT | PS2_CFG_TRANSLATION);
-    ps2_post_cmd(PS2_CMD_WRITE_CFG, result);
+    ps2_post_cmd(PS2_PORT_CTRL_CMDREG, PS2_CMD_WRITE_CFG, result);
 
     // 4、控制器自检
     result = ps2_issue_cmd(PS2_CMD_SELFTEST, PS2_NO_ARG);
@@ -127,10 +133,10 @@ void ps2_kbd_init() {
     }
 
     // 6、开启位于端口1的 IRQ，并启用端口1。不用理会端口2，那儿一般是鼠标。
-    ps2_post_cmd(PS2_CMD_PORT1_ENABLE, PS2_NO_ARG);
+    ps2_post_cmd(PS2_PORT_CTRL_CMDREG, PS2_CMD_PORT1_ENABLE, PS2_NO_ARG);
     result = ps2_issue_cmd(PS2_CMD_READ_CFG, PS2_NO_ARG);
     result = result | PS2_CFG_P1INT;
-    ps2_post_cmd(PS2_CMD_WRITE_CFG, result);
+    ps2_post_cmd(PS2_PORT_CTRL_CMDREG, PS2_CMD_WRITE_CFG, result);
 
     // 至此，PS/2控制器和设备已完成初始化，可以正常使用。
 
@@ -147,12 +153,18 @@ done:
 }
 
 void ps2_process_cmd(void* arg) {
-    // FIXME: Need a mutex lock on this.
-    // if lock is hold by other, then it just simply return (not wait! as we are in isr).
-    if (!cmd_q.queue_len) {
+    // 检查锁是否已被启用，如果启用，则表明该timer中断发生时，某个指令正在入队。
+    // 如果是这种情况则跳过，留到下一轮再尝试处理。
+    // 注意，这里其实是ISR的一部分（timer中断），对于单核CPU来说，ISR等同于单个的原子操作。
+    // （因为EFLAGS.IF=0，所有可屏蔽中断被屏蔽。对于NMI的情况，那么就直接算是triple fault了，所以也没有讨论的意义）
+    // 所以，假若我们遵从互斥锁的严格定义（即这里需要阻塞），那么中断将会被阻塞，进而造成死锁。
+    // 因此，我们这里仅仅进行判断。
+    // 会不会产生指令堆积？不会，因为指令发送的频率远远低于指令队列清空的频率。在目前，我们发送的唯一指令
+    // 就只是用来开关键盘上的LED灯（如CAPSLOCK）。
+    if (!cmd_q.queue_len || cmd_q.lock) {
         return;
     }
-
+    
     // 处理队列排头的指令
     struct ps2_cmd *pending_cmd = &cmd_q.cmd_queue[cmd_q.queue_ptr];
     char result;
@@ -162,41 +174,77 @@ void ps2_process_cmd(void* arg) {
     // 如果不成功（0x60 IO口返回 0xfe，即 NAK 或 Resend）
     // 则尝试最多五次
     do {
-        result = ps2_issue_cmd(pending_cmd->cmd, pending_cmd->arg);
+        result = ps2_issue_dev_cmd(pending_cmd->cmd, pending_cmd->arg);
         attempts++;
     } while(result == PS2_RESULT_NAK && attempts < PS2_DEV_CMD_MAX_ATTEMPTS);
     
-    // TODO: 是否需要处理不成功的指令？
+    // XXX: 是否需要处理不成功的指令？
 
     cmd_q.queue_ptr = (cmd_q.queue_ptr + 1) % PS2_CMD_QUEUE_SIZE;
     cmd_q.queue_len--;
 }
 
-void kbd_buffer_key_event(kbd_keycode key, uint8_t scancode, kbd_kstate_t state) {
+static struct kdb_keyinfo_pkt* ps2_keybuffer_next_write() {
+    int index = (key_buf.read_ptr + key_buf.buffered_len) % PS2_KBD_RECV_BUFFER_SIZE;
+    if (index == key_buf.read_ptr && key_buf.buffered_len) {
+        // the reader lagged so much. It is suggested to read from beginning.
+        key_buf.read_ptr = 0;
+        key_buf.buffered_len = index;
+    }
+    else {
+        key_buf.buffered_len++;
+    }
+    return &key_buf.buffer[index];
+}
+
+void kbd_buffer_key_event(kbd_keycode_t key, uint8_t scancode, kbd_kstate_t state) {
+    // forgive me on these ugly bit-level tricks, 
+    // I really hate doing branching on these "fliping switch" things
     if (key == KEY_CAPSLK) {
-        kbd_state.key_state = kbd_state.key_state ^ (KBD_KEY_CAPSLKED & -state);
+        kbd_state.key_state ^= KBD_KEY_FCAPSLKED & -state;
     } else if (key == KEY_NUMSLK) {
-        kbd_state.key_state = kbd_state.key_state ^ (KBD_KEY_NUMBLKED & -state);
+        kbd_state.key_state ^= KBD_KEY_FNUMBLKED & -state;
     } else if (key == KEY_SCRLLK) {
-        kbd_state.key_state = kbd_state.key_state ^ (KBD_KEY_SCRLLKED & -state);
+        kbd_state.key_state ^= KBD_KEY_FSCRLLKED & -state;
     } else {
+        if ((key & MODIFR)) {
+            kbd_kstate_t tmp = (KBD_KEY_FLSHIFT_HELD << (key & 0x00ff));
+            kbd_state.key_state = (kbd_state.key_state & ~tmp) | (tmp & -state);
+        }
+        else if (!(key & 0xff00) && (kbd_state.key_state & (KBD_KEY_FLSHIFT_HELD | KBD_KEY_FRSHIFT_HELD))) {
+            key = scancode_set2_shift[scancode];
+        }
         state = state | kbd_state.key_state;
+        key = key & (0xffdf | -('a' > key || key > 'z' || !(state & KBD_KEY_FCAPSLKED)));
         time_t timestamp = clock_systime();
         // TODO: Construct the packet.
-        kprintf(KDEBUG "%c (t=%d, s=%x, c=%d)\n", key & 0x00ff, timestamp, state, (key & 0xff00) >> 8);
+        if (!key_buf.lock) {
+            struct kdb_keyinfo_pkt* keyevent_pkt = ps2_keybuffer_next_write();
+            keyevent_pkt->keycode = key;
+            keyevent_pkt->scancode = scancode;
+            keyevent_pkt->state = state;
+            keyevent_pkt->timestamp = timestamp;
+        }
+
+        // kprintf(KDEBUG "%c (t=%d, s=%x, c=%d)\n", key & 0x00ff, timestamp, state, key >> 8);
         return; // do not delete this return
     }
 
-    ps2_device_post_cmd(PS2_KBD_CMD_SETLED, kbd_state.key_state >> 1);
+    // Ooops, this guy generates irq!
+    ps2_device_post_cmd(PS2_KBD_CMD_SETLED, (kbd_state.key_state >> 1) & 0x00ff);
 }
 
 void intr_ps2_kbd_handler(const isr_param* param) {
-    uint8_t scancode = io_inb(PS2_PORT_DATA) & 0xff;
-    kbd_keycode key;
+    uint8_t scancode = io_inb(PS2_PORT_ENC_DATA) & 0xff;
+    kbd_keycode_t key;
 
-    kprintf(KINFO "%x\n", scancode & 0xff);
+    // 用于区分0xfe,0xfa等指令返回码。
+    if (scancode >= 0xFA) {
+        return;
+    }
+    
+    //kprintf(KINFO "%x\n", scancode & 0xff);
     
-    // FIXME: 实现 Shift+<key> 
     switch (kbd_state.state)
     {
     case KBD_STATE_WAIT_KEY:
@@ -207,7 +255,7 @@ void intr_ps2_kbd_handler(const isr_param* param) {
             kbd_state.translation_table = scancode_set2_ex;
         } else {
             key = kbd_state.translation_table[scancode];
-            kbd_buffer_key_event(key, scancode, KBD_KEY_PRESSED);
+            kbd_buffer_key_event(key, scancode, KBD_KEY_FPRESSED);
         }
         break;
     case KBD_STATE_SPECIAL:
@@ -215,7 +263,7 @@ void intr_ps2_kbd_handler(const isr_param* param) {
             kbd_state.state = KBD_STATE_RELEASED;       
         } else {
             key = kbd_state.translation_table[scancode];
-            kbd_buffer_key_event(key, scancode, KBD_KEY_PRESSED);
+            kbd_buffer_key_event(key, scancode, KBD_KEY_FPRESSED);
 
             kbd_state.state = KBD_STATE_WAIT_KEY;
             kbd_state.translation_table = scancode_set2;
@@ -223,11 +271,11 @@ void intr_ps2_kbd_handler(const isr_param* param) {
         break;
     case KBD_STATE_RELEASED:
         key = kbd_state.translation_table[scancode];
-        kbd_buffer_key_event(key, scancode, KBD_KEY_RELEASED);
+        kbd_buffer_key_event(key, scancode, KBD_KEY_FRELEASED);
         
         // reset the translation table to scancode_set2
-        kbd_state.translation_table = scancode_set2;
         kbd_state.state = KBD_STATE_WAIT_KEY;   
+        kbd_state.translation_table = scancode_set2;
         break;
     
     default:
@@ -236,24 +284,58 @@ void intr_ps2_kbd_handler(const isr_param* param) {
 }
 
 static uint8_t ps2_issue_cmd(char cmd, uint16_t arg) {
-    ps2_post_cmd(cmd, arg);
+    ps2_post_cmd(PS2_PORT_CTRL_CMDREG, cmd, arg);
 
     char result;
     
     // 等待PS/2控制器返回。通过轮询（polling）状态寄存器的 bit 0
     // 如置位，则表明返回代码此时就在 0x60 IO口上等待读取。
-    while(!((result = io_inb(PS2_PORT_STATUS)) & PS2_STATUS_OFULL));
+    while(!((result = io_inb(PS2_PORT_CTRL_STATUS)) & PS2_STATUS_OFULL));
 
-    return io_inb(PS2_PORT_DATA);
+    return io_inb(PS2_PORT_ENC_CMDREG);
 }
 
-static void ps2_post_cmd(char cmd, uint16_t arg) {
+static uint8_t ps2_issue_dev_cmd(char cmd, uint16_t arg) {
+    ps2_post_cmd(PS2_PORT_ENC_CMDREG, cmd, arg);
+
+    char result;
+    
+    // 等待PS/2控制器返回。通过轮询（polling）状态寄存器的 bit 0
+    // 如置位，则表明返回代码此时就在 0x60 IO口上等待读取。
+    while(!((result = io_inb(PS2_PORT_CTRL_STATUS)) & PS2_STATUS_OFULL));
+
+    return io_inb(PS2_PORT_ENC_CMDREG);
+}
+
+static void ps2_post_cmd(uint8_t port, char cmd, uint16_t arg) {
     char result;
     // 等待PS/2输入缓冲区清空，这样我们才可以写入命令
-    while((result = io_inb(PS2_PORT_STATUS)) & PS2_STATUS_IFULL);
+    while((result = io_inb(PS2_PORT_CTRL_STATUS)) & PS2_STATUS_IFULL);
 
-    io_outb(PS2_PORT_CMDREG, cmd);
+    io_outb(port, cmd);
     if (!(arg & PS2_NO_ARG)) {
-        io_outb(PS2_PORT_DATA, (uint8_t)(arg & 0x00ff));
+        // 所有参数一律通过0x60传入。
+        io_outb(PS2_PORT_ENC_CMDREG, (uint8_t)(arg & 0x00ff));
     }
 }
+
+struct kdb_keyinfo_pkt* kbd_try_read_one() {
+    if (!key_buf.buffered_len) {
+        return NULL;
+    }
+    key_buf.lock = 1;
+    struct kdb_keyinfo_pkt* pkt_copy = 
+        (struct kdb_keyinfo_pkt*) lxmalloc(sizeof(struct kdb_keyinfo_pkt));
+
+    struct kdb_keyinfo_pkt* pkt_current = &key_buf.buffer[key_buf.read_ptr];
+
+    pkt_copy->keycode = pkt_current->keycode;
+    pkt_copy->scancode = pkt_current->scancode;
+    pkt_copy->state = pkt_current->state;
+    pkt_copy->timestamp = pkt_current->timestamp;
+    key_buf.buffered_len--;
+    key_buf.read_ptr = (key_buf.read_ptr + 1) % PS2_KBD_RECV_BUFFER_SIZE;
+
+    key_buf.lock = 0;
+    return pkt_copy;
+}
\ No newline at end of file
diff --git a/lunaix-os/kernel/tty/tty.c b/lunaix-os/kernel/tty/tty.c
index cc70087..4a20a77 100644
--- a/lunaix-os/kernel/tty/tty.c
+++ b/lunaix-os/kernel/tty/tty.c
@@ -41,6 +41,10 @@ tty_put_char(char chr)
         case '\r':
             tty_x = 0;
             break;
+        case '\x08':
+            tty_x = tty_x ? tty_x - 1 : 0;
+            *(tty_vga_buffer + tty_x + tty_y * TTY_WIDTH) = (tty_theme_color | 0x20);
+            break;
         default:
             *(tty_vga_buffer + tty_x + tty_y * TTY_WIDTH) = (tty_theme_color | chr);
             tty_x++;
diff --git a/lunaix-os/makefile b/lunaix-os/makefile
index 164bf5c..58bc9d7 100644
--- a/lunaix-os/makefile
+++ b/lunaix-os/makefile
@@ -39,7 +39,7 @@ $(BUILD_DIR)/$(OS_ISO): $(ISO_DIR) $(BIN_DIR)/$(OS_BIN) GRUB_TEMPLATE
 
 all: clean $(BUILD_DIR)/$(OS_ISO)
 
-all-debug: O := -O0
+all-debug: O := -Og
 all-debug: CFLAGS := -g -std=gnu99 -ffreestanding $(O) $(W) $(ARCH_OPT) -D__LUNAIXOS_DEBUG__
 all-debug: LDFLAGS := -g -ffreestanding $(O) -nostdlib -lgcc
 all-debug: clean $(BUILD_DIR)/$(OS_ISO)
-- 
2.27.0