chore: fix almost *ALL* warnings.

[lunaix-os.git] / lunaix-os / kernel / peripheral / ps2kbd.c

diff --git a/lunaix-os/kernel/peripheral/ps2kbd.c b/lunaix-os/kernel/peripheral/ps2kbd.c
index ece9eab778774a9c21d09cc0f8361db09835ee7b..c31d73666b84fa4e7d849b97d80ef98720a562f3 100644 (file)
--- a/lunaix-os/kernel/peripheral/ps2kbd.c
+++ b/lunaix-os/kernel/peripheral/ps2kbd.c
@@ -1,30 +1,33 @@
-#include <lunaix/peripheral/ps2kbd.h>
+#include <hal/acpi/acpi.h>
+#include <hal/ioapic.h>

 #include <lunaix/clock.h>
 #include <lunaix/clock.h>

-#include <lunaix/timer.h>

 #include <lunaix/common.h>
 #include <lunaix/common.h>

+#include <lunaix/input.h>
+#include <lunaix/isrm.h>
+#include <lunaix/peripheral/ps2kbd.h>

 #include <lunaix/syslog.h>
 #include <lunaix/syslog.h>

-#include <hal/acpi/acpi.h>
-#include <hal/ioapic.h>
+#include <lunaix/timer.h>

 
 

-#include <hal/cpu.h>

 #include <arch/x86/interrupts.h>
 #include <arch/x86/interrupts.h>

+#include <hal/cpu.h>

 #include <klibc/string.h>
 
 #include <stdint.h>
 
 #define PS2_DEV_CMD_MAX_ATTEMPTS 5
 
 #include <klibc/string.h>
 
 #include <stdint.h>
 
 #define PS2_DEV_CMD_MAX_ATTEMPTS 5
 

-LOG_MODULE("PS2KBD");
+LOG_MODULE("i8042");

 
 static struct ps2_cmd_queue cmd_q;
 
 static struct ps2_cmd_queue cmd_q;

-static struct ps2_key_buffer key_buf;

 static struct ps2_kbd_state kbd_state;
 
 static struct ps2_kbd_state kbd_state;
 

-#define KEY_NUM(x)      (x + 0x30)
-#define KEY_NPAD(x)      ON_KEYPAD(KEY_NUM(x))
+#define KEY_NUM(x) (x + 0x30)
+#define KEY_NPAD(x) ON_KEYPAD(KEY_NUM(x))

 
 // 我们使用 Scancode Set 2
 
 
 // 我们使用 Scancode Set 2
 

+// clang-format off
+

 // 大部分的扫描码（键码）
 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,
 // 大部分的扫描码（键码）
 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,


@@ -65,19 +68,30 @@ static kbd_keycode_t scancode_set2_shift[] = {
     KEY_NPAD(3), ON_KEYPAD('-'), ON_KEYPAD('*'), KEY_SCRLLK, 0, 0, 0, 0, KEY_F7
 };
 
     KEY_NPAD(3), ON_KEYPAD('-'), ON_KEYPAD('*'), KEY_SCRLLK, 0, 0, 0, 0, KEY_F7
 };
 

+// clang-format on
+
+static struct input_device* kbd_idev;

 
 

-#define KBD_STATE_KWAIT         0x00
-#define KBD_STATE_KSPECIAL      0x01
-#define KBD_STATE_KRELEASED     0x02
-#define KBD_STATE_CMDPROCS      0x40
+#define KBD_STATE_KWAIT 0x00
+#define KBD_STATE_KSPECIAL 0x01
+#define KBD_STATE_KRELEASED 0x02
+#define KBD_STATE_E012 0x03
+#define KBD_STATE_KRELEASED_E0 0x04
+#define KBD_STATE_CMDPROCS 0x40

 
 

-#define KBD_ENABLE_SPIRQ_FIX
+// #define KBD_ENABLE_SPIRQ_FIX
+#define KBD_ENABLE_SPIRQ_FIX2

 // #define KBD_DBGLOG
 
 // #define KBD_DBGLOG
 

-void intr_ps2_kbd_handler(const isr_param* param);
-static struct kdb_keyinfo_pkt* ps2_keybuffer_next_write();
+void
+intr_ps2_kbd_handler(const isr_param* param);

 
 

-void ps2_device_post_cmd(char cmd, char arg) {
+static u8_t
+ps2_issue_cmd_wretry(char cmd, u16_t arg);
+
+void
+ps2_device_post_cmd(char cmd, char arg)
+{

     mutex_lock(&cmd_q.mutex);
     int index = (cmd_q.queue_ptr + cmd_q.queue_len) % PS2_CMD_QUEUE_SIZE;
     if (index == cmd_q.queue_ptr && cmd_q.queue_len) {
     mutex_lock(&cmd_q.mutex);
     int index = (cmd_q.queue_ptr + cmd_q.queue_len) % PS2_CMD_QUEUE_SIZE;
     if (index == cmd_q.queue_ptr && cmd_q.queue_len) {


@@ -86,7 +100,7 @@ void ps2_device_post_cmd(char cmd, char arg) {
         return;
     }
 
         return;
     }
 

-    struct ps2_cmd *container = &cmd_q.cmd_queue[index];
+    struct ps2_cmd* container = &cmd_q.cmd_queue[index];

     container->cmd = cmd;
     container->arg = arg;
     cmd_q.queue_len++;
     container->cmd = cmd;
     container->arg = arg;
     cmd_q.queue_len++;


@@ -95,82 +109,88 @@ void ps2_device_post_cmd(char cmd, char arg) {
     mutex_unlock(&cmd_q.mutex);
 }
 
     mutex_unlock(&cmd_q.mutex);
 }
 

-void ps2_kbd_init() {
+void
+ps2_kbd_init()
+{

 
     memset(&cmd_q, 0, sizeof(cmd_q));
 
     memset(&cmd_q, 0, sizeof(cmd_q));

-    memset(&key_buf, 0, sizeof(key_buf));

     memset(&kbd_state, 0, sizeof(kbd_state));
     memset(&kbd_state, 0, sizeof(kbd_state));

-    
-    mutex_init(&cmd_q.mutex);
-    mutex_init(&key_buf.mutex);

 
 

+    mutex_init(&cmd_q.mutex);

 
     kbd_state.translation_table = scancode_set2;
     kbd_state.state = KBD_STATE_KWAIT;
 
 
     kbd_state.translation_table = scancode_set2;
     kbd_state.state = KBD_STATE_KWAIT;
 

+    kbd_idev = input_add_device("i8042-kbd");
+

     acpi_context* acpi_ctx = acpi_get_context();
     if (acpi_ctx->fadt.header.rev > 1) {
         /*
          *  只有当前ACPI版本大于1时，我们才使用FADT的IAPC_BOOT_ARCH去判断8042是否存在。
          *  这是一个坑，在ACPI v1中，这个字段是reserved！而这及至ACPI v2才出现。
     acpi_context* acpi_ctx = acpi_get_context();
     if (acpi_ctx->fadt.header.rev > 1) {
         /*
          *  只有当前ACPI版本大于1时，我们才使用FADT的IAPC_BOOT_ARCH去判断8042是否存在。
          *  这是一个坑，在ACPI v1中，这个字段是reserved！而这及至ACPI v2才出现。

-         *  需要注意：Bochs 和 QEMU 使用的是ACPI v1，而非 v2 （virtualbox好像是v4）
-         * 
+         *  需要注意：Bochs 和 QEMU 使用的是ACPI v1，而非 v2
+         * （virtualbox好像是v4）
+         *
+         *  (2022/6/29)
+         *  QEMU在7.0.0版本中，修复了FADT::IAPC_BOOT无法正确提供关于i8042的信息的bug
+         *      https://wiki.qemu.org/ChangeLog/7.0#ACPI_.2F_SMBIOS
+         *

          *  请看Bochs的bios源码（QEMU的BIOS其实是照抄bochs的，所以也是一个德行。。）：
          *      https://bochs.sourceforge.io/cgi-bin/lxr/source/bios/rombios32.c#L1314
          */
         if (!(acpi_ctx->fadt.boot_arch & IAPC_ARCH_8042)) {
          *  请看Bochs的bios源码（QEMU的BIOS其实是照抄bochs的，所以也是一个德行。。）：
          *      https://bochs.sourceforge.io/cgi-bin/lxr/source/bios/rombios32.c#L1314
          */
         if (!(acpi_ctx->fadt.boot_arch & IAPC_ARCH_8042)) {

-            kprintf(KERROR "No PS/2 controller detected.\n");
-            // FUTURE: Some alternative fallback on this? Check PCI bus for USB controller instead?
+            kprintf(KERROR "not found\n");
+            // FUTURE: Some alternative fallback on this? Check PCI bus for USB
+            // controller instead?

             return;
         }
             return;
         }

+    } else {
+        kprintf(KWARN "outdated FADT used, assuming exists.\n");

     }
     }

-    else {
-        kprintf(KWARN "Outdated FADT used, assuming 8042 always exist.\n");
-    }
-    
+

     char result;
     char result;

-    
+

     cpu_disable_interrupt();
 
     // 1、禁用任何的PS/2设备
     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);
     cpu_disable_interrupt();
 
     // 1、禁用任何的PS/2设备
     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_ENC_DATA);
 
     // 2、清空控制器缓冲区
     io_inb(PS2_PORT_ENC_DATA);
 

-

     // 3、屏蔽所有PS/2设备（端口1&2）IRQ，并且禁用键盘键码转换功能
     result = ps2_issue_cmd(PS2_CMD_READ_CFG, PS2_NO_ARG);
     // 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);
+    result = result & ~(PS2_CFG_P1INT | PS2_CFG_P2INT);

     ps2_post_cmd(PS2_PORT_CTRL_CMDREG, PS2_CMD_WRITE_CFG, result);
 
     // 4、控制器自检
     ps2_post_cmd(PS2_PORT_CTRL_CMDREG, PS2_CMD_WRITE_CFG, result);
 
     // 4、控制器自检

-    result = ps2_issue_cmd(PS2_CMD_SELFTEST, PS2_NO_ARG);
+    result = ps2_issue_cmd_wretry(PS2_CMD_SELFTEST, PS2_NO_ARG);

     if (result != PS2_RESULT_TEST_OK) {
     if (result != PS2_RESULT_TEST_OK) {

-        kprintf(KERROR "Controller self-test failed.");
-        goto done;
+        kprintf(KWARN "controller self-test failed. (%x)\n", result);
+        // goto done;

     }
 
     // 5、设备自检（端口1自检，通常是我们的键盘）
     }
 
     // 5、设备自检（端口1自检，通常是我们的键盘）

-    result = ps2_issue_cmd(PS2_CMD_SELFTEST_PORT1, PS2_NO_ARG);
+    result = ps2_issue_cmd_wretry(PS2_CMD_SELFTEST_PORT1, PS2_NO_ARG);

     if (result != 0) {
     if (result != 0) {

-        kprintf(KERROR "Interface test on port 1 failed.");
-        goto done;
+        kprintf(KERROR "interface test on port 1 failed. (%x)\n", result);
+        // goto done;

     }
 
     }
 

+    ps2_post_cmd(PS2_PORT_CTRL_CMDREG, PS2_CMD_PORT2_DISABLE, PS2_NO_ARG);
+

     // 6、开启位于端口1的 IRQ，并启用端口1。不用理会端口2，那儿一般是鼠标。
     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);
     // 6、开启位于端口1的 IRQ，并启用端口1。不用理会端口2，那儿一般是鼠标。
     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;
+    // 重新设置配置字节，因为控制器自检有可能重置我们先前做的改动。
+    result = (result | PS2_CFG_P1INT) & ~(PS2_CFG_TRANSLATION | PS2_CFG_P2INT);

     ps2_post_cmd(PS2_PORT_CTRL_CMDREG, PS2_CMD_WRITE_CFG, result);
 
     // 至此，PS/2控制器和设备已完成初始化，可以正常使用。
 
     ps2_post_cmd(PS2_PORT_CTRL_CMDREG, PS2_CMD_WRITE_CFG, result);
 
     // 至此，PS/2控制器和设备已完成初始化，可以正常使用。
 

-    // 将我们的键盘驱动挂载到第204号中断上（已由IOAPIC映射至IRQ#1），
-    intr_subscribe(PC_KBD_IV, intr_ps2_kbd_handler);
-
-    // 搞一个计时器，将我们的 ps2_process_cmd 挂上去。每隔5毫秒执行排在队头的命令。
+    // 搞一个计时器，将我们的 ps2_process_cmd
+    // 挂上去。每隔5毫秒执行排在队头的命令。

     //  为什么只执行队头的命令，而不是全部的命令？
     //      因为我们需要保证isr尽量的简短，运行起来快速。而发送这些命令非常的耗时。
     timer_run_ms(5, ps2_process_cmd, NULL, TIMER_MODE_PERIODIC);
     //  为什么只执行队头的命令，而不是全部的命令？
     //      因为我们需要保证isr尽量的简短，运行起来快速。而发送这些命令非常的耗时。
     timer_run_ms(5, ps2_process_cmd, NULL, TIMER_MODE_PERIODIC);


@@ -182,22 +202,23 @@ void ps2_kbd_init() {
      *  初始化8042，屏蔽了所有中断，IF=0）。
      *  当sti后，这些堆积的中断会紧跟着递送进CPU里，导致我们的键盘handler误认为由按键按下，从而将这个毫无意义的数值加入
      *  我们的队列中，以供上层读取。
      *  初始化8042，屏蔽了所有中断，IF=0）。
      *  当sti后，这些堆积的中断会紧跟着递送进CPU里，导致我们的键盘handler误认为由按键按下，从而将这个毫无意义的数值加入
      *  我们的队列中，以供上层读取。

-     *  
-     *  所以，保险的方法是：在初始化后才去设置ioapic，这样一来我们就能有一个稳定的IRQ#1以放心使用。  
-    */
-    uint8_t irq_kbd = ioapic_get_irq(acpi_ctx, PC_AT_IRQ_KBD);
-    ioapic_redirect(irq_kbd, PC_KBD_IV, 0, IOAPIC_DELMOD_FIXED);
+     *
+     *  所以，保险的方法是：在初始化后才去设置ioapic，这样一来我们就能有一个稳定的IRQ#1以放心使用。
+     */
+    isrm_bindirq(PC_AT_IRQ_KBD, intr_ps2_kbd_handler);

 
 

-done:

     cpu_enable_interrupt();
 }
 
     cpu_enable_interrupt();
 }
 

-void ps2_process_cmd(void* arg) {
-    /* 
+void
+ps2_process_cmd(void* arg)
+{
+    /*

      * 检查锁是否已被启用，如果启用，则表明该timer中断发生时，某个指令正在入队。
      * 如果是这种情况则跳过，留到下一轮再尝试处理。
      * 注意，这里其实是ISR的一部分（timer中断），对于单核CPU来说，ISR等同于单个的原子操作。
      * 检查锁是否已被启用，如果启用，则表明该timer中断发生时，某个指令正在入队。
      * 如果是这种情况则跳过，留到下一轮再尝试处理。
      * 注意，这里其实是ISR的一部分（timer中断），对于单核CPU来说，ISR等同于单个的原子操作。

-     * （因为EFLAGS.IF=0，所有可屏蔽中断被屏蔽。对于NMI的情况，那么就直接算是triple fault了，所以也没有讨论的意义）
+     * （因为EFLAGS.IF=0，所有可屏蔽中断被屏蔽。对于NMI的情况，那么就直接算是triple
+     * fault了，所以也没有讨论的意义）

      * 所以，假若我们遵从互斥锁的严格定义（即这里需要阻塞），那么中断将会被阻塞，进而造成死锁。
      * 因此，我们这里仅仅进行判断。
      * 会不会产生指令堆积？不会，因为指令发送的频率远远低于指令队列清空的频率。在目前，我们发送的唯一指令
      * 所以，假若我们遵从互斥锁的严格定义（即这里需要阻塞），那么中断将会被阻塞，进而造成死锁。
      * 因此，我们这里仅仅进行判断。
      * 会不会产生指令堆积？不会，因为指令发送的频率远远低于指令队列清空的频率。在目前，我们发送的唯一指令


@@ -208,8 +229,8 @@ void ps2_process_cmd(void* arg) {
     }
 
     // 处理队列排头的指令
     }
 
     // 处理队列排头的指令

-    struct ps2_cmd *pending_cmd = &cmd_q.cmd_queue[cmd_q.queue_ptr];
-    char result;
+    struct ps2_cmd* pending_cmd = &cmd_q.cmd_queue[cmd_q.queue_ptr];
+    u8_t result;

     int attempts = 0;
 
     // 尝试将命令发送至PS/2键盘（通过PS/2控制器）
     int attempts = 0;
 
     // 尝试将命令发送至PS/2键盘（通过PS/2控制器）


@@ -221,18 +242,19 @@ void ps2_process_cmd(void* arg) {
         kbd_state.state += KBD_STATE_CMDPROCS;
 #endif
         attempts++;
         kbd_state.state += KBD_STATE_CMDPROCS;
 #endif
         attempts++;

-    } while(result == PS2_RESULT_NAK && attempts < PS2_DEV_CMD_MAX_ATTEMPTS);
-    
+    } while (result == PS2_RESULT_NAK && attempts < PS2_DEV_CMD_MAX_ATTEMPTS);

     // XXX: 是否需要处理不成功的指令？
 
     cmd_q.queue_ptr = (cmd_q.queue_ptr + 1) % PS2_CMD_QUEUE_SIZE;
     cmd_q.queue_len--;
 }
 
     // 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_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 
+void
+kbd_buffer_key_event(kbd_keycode_t key, u8_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_KEY_FCAPSLKED & -state;
     */
     if (key == KEY_CAPSLK) {
         kbd_state.key_state ^= KBD_KEY_FCAPSLKED & -state;


@@ -244,62 +266,71 @@ void kbd_buffer_key_event(kbd_keycode_t key, uint8_t scancode, kbd_kstate_t stat
         if ((key & MODIFR)) {
             kbd_kstate_t tmp = (KBD_KEY_FLSHIFT_HELD << (key & 0x00ff));
             kbd_state.key_state = (kbd_state.key_state & ~tmp) | (tmp & -state);
         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))) {
+        } 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 = scancode_set2_shift[scancode];
         }
         state = state | kbd_state.key_state;

-        key = key & (0xffdf | -('a' > key || key > 'z' || !(state & KBD_KEY_FCAPSLKED)));
-
-        if (!mutex_on_hold(&key_buf.mutex)) {
-            struct kdb_keyinfo_pkt* keyevent_pkt = ps2_keybuffer_next_write();
-            *keyevent_pkt = (struct kdb_keyinfo_pkt) {
-                .keycode = key,
-                .scancode = scancode,
-                .state = state,
-                .timestamp = clock_systime()
-            };
-        }
+        key = key & (0xffdf |
+                     -('a' > key || key > 'z' || !(state & KBD_KEY_FCAPSLKED)));
+
+        struct input_evt_pkt ipkt = { .pkt_type = (state & KBD_KEY_FPRESSED)
+                                                    ? PKT_PRESS
+                                                    : PKT_RELEASE,
+                                      .scan_code = scancode,
+                                      .sys_code = (state << 16) | key };
+
+        input_fire_event(kbd_idev, &ipkt);

 
         return;
     }
 
     if (state & KBD_KEY_FPRESSED) {
         // Ooops, this guy generates irq!
 
         return;
     }
 
     if (state & KBD_KEY_FPRESSED) {
         // Ooops, this guy generates irq!

-        ps2_device_post_cmd(PS2_KBD_CMD_SETLED, (kbd_state.key_state >> 1) & 0x00ff);
+        ps2_device_post_cmd(PS2_KBD_CMD_SETLED,
+                            (kbd_state.key_state >> 1) & 0x00ff);

     }
 }
 
     }
 }
 

-void intr_ps2_kbd_handler(const isr_param* param) {
+void
+intr_ps2_kbd_handler(const isr_param* param)
+{

 
     // This is important! Don't believe me? try comment it out and run on Bochs!
 
     // This is important! Don't believe me? try comment it out and run on Bochs!

-    while (!(io_inb(PS2_PORT_CTRL_STATUS) & PS2_STATUS_OFULL));
-
-    // I know you are tempting to move this chunk after the keyboard state check.
-    // But DO NOT. This chunk is in right place and right order. Moving it at your own risk 
-    // This is to ensure we've cleared the output buffer everytime, so it won't pile up across irqs.
-    uint8_t scancode = io_inb(PS2_PORT_ENC_DATA);
+    // while (!(io_inb(PS2_PORT_CTRL_STATUS) & PS2_STATUS_OFULL))
+    //    ;
+
+    // I know you are tempting to move this chunk after the keyboard state
+    // check. But DO NOT. This chunk is in right place and right order. Moving
+    // it at your own risk This is to ensure we've cleared the output buffer
+    // everytime, so it won't pile up across irqs.
+    u8_t scancode = io_inb(PS2_PORT_ENC_DATA);

     kbd_keycode_t key;
 
     kbd_keycode_t key;
 

-    /*  
+    /*

      *    判断键盘是否处在指令发送状态，防止误触发。（伪输入中断）
      * 这是因为我们需要向ps/2设备发送指令（比如控制led灯），而指令会有返回码。
      * 这就会有可能导致ps/2控制器在受到我们的命令后（在ps2_process_cmd中），
      * 产生IRQ#1中断（虽然说这种情况取决于底层BIOS实现，但还是会发生，比如QEMU和bochs）。
      * 所以这就是说，当IRQ#1中断产生时，我们的CPU正处在另一个ISR中。这样就会导致所有的外部中断被缓存在APIC内部的
      *    判断键盘是否处在指令发送状态，防止误触发。（伪输入中断）
      * 这是因为我们需要向ps/2设备发送指令（比如控制led灯），而指令会有返回码。
      * 这就会有可能导致ps/2控制器在受到我们的命令后（在ps2_process_cmd中），
      * 产生IRQ#1中断（虽然说这种情况取决于底层BIOS实现，但还是会发生，比如QEMU和bochs）。
      * 所以这就是说，当IRQ#1中断产生时，我们的CPU正处在另一个ISR中。这样就会导致所有的外部中断被缓存在APIC内部的

-     * FIFO队列里，进行排队等待（APIC长度为二的队列 {IRR, TMR}；参考 Intel Manual Vol.3A 10.8.4）
+     * FIFO队列里，进行排队等待（APIC长度为二的队列 {IRR, TMR}；参考 Intel
+     * Manual Vol.3A 10.8.4）

      * 那么当ps2_process_cmd执行完后（内嵌在#APIC_TIMER_IV），CPU返回EOI给APIC，APIC紧接着将排在队里的IRQ#1发送给CPU
      * 造成误触发。也就是说，我们此时读入的scancode实则上是上一个指令的返回代码。
      * 那么当ps2_process_cmd执行完后（内嵌在#APIC_TIMER_IV），CPU返回EOI给APIC，APIC紧接着将排在队里的IRQ#1发送给CPU
      * 造成误触发。也就是说，我们此时读入的scancode实则上是上一个指令的返回代码。

-     * 
+     *

      * Problem 1 (Fixed):
      *      但是这种方法有个问题，那就是，假若我们的某一个命令失败了一次，ps/2给出0xfe，我们重传，ps/2收到指令并给出0xfa。
      *  那么这样一来，将会由两个连续的IRQ#1产生。而APIC是最多可以缓存两个IRQ，于是我们就会漏掉一个IRQ，依然会误触发。
      * Solution:
      *      累加掩码 ;)
      * Problem 1 (Fixed):
      *      但是这种方法有个问题，那就是，假若我们的某一个命令失败了一次，ps/2给出0xfe，我们重传，ps/2收到指令并给出0xfa。
      *  那么这样一来，将会由两个连续的IRQ#1产生。而APIC是最多可以缓存两个IRQ，于是我们就会漏掉一个IRQ，依然会误触发。
      * Solution:
      *      累加掩码 ;)

-     * 
+     *

      * Problem 2:
      * Problem 2:

-     *    + 这种累加掩码的操作是基于只有一号IRQ产生的中断的假设，万一中间夹杂了别的中断？Race Condition!
-     *    + 不很稳定x1，假如连续4次发送失败，那么就会导致累加的掩码上溢出，从而导致下述判断失败。
+     *    +
+     * 这种累加掩码的操作是基于只有一号IRQ产生的中断的假设，万一中间夹杂了别的中断？Race
+     * Condition!
+     *    +
+     * 不很稳定x1，假如连续4次发送失败，那么就会导致累加的掩码上溢出，从而导致下述判断失败。

      */
 #ifdef KBD_ENABLE_SPIRQ_FIX
     if ((kbd_state.state & 0xc0)) {
      */
 #ifdef KBD_ENABLE_SPIRQ_FIX
     if ((kbd_state.state & 0xc0)) {


@@ -309,108 +340,122 @@ void intr_ps2_kbd_handler(const isr_param* param) {
     }
 #endif
 
     }
 #endif
 

+#ifdef KBD_ENABLE_SPIRQ_FIX2
+    if (scancode == PS2_RESULT_ACK || scancode == PS2_RESULT_NAK) {
+        return;
+    }
+#endif
+

 #ifdef KBD_DBGLOG
     kprintf(KDEBUG "%x\n", scancode & 0xff);
 #endif
 #ifdef KBD_DBGLOG
     kprintf(KDEBUG "%x\n", scancode & 0xff);
 #endif

-    
-    switch (kbd_state.state)
-    {
-    case KBD_STATE_KWAIT:
-        if (scancode == 0xf0) { // release code
-            kbd_state.state = KBD_STATE_KRELEASED;       
-        } else if (scancode == 0xe0) {
-            kbd_state.state = KBD_STATE_KSPECIAL;
-            kbd_state.translation_table = scancode_set2_ex;
-        } else {
-            key = kbd_state.translation_table[scancode];
-            kbd_buffer_key_event(key, scancode, KBD_KEY_FPRESSED);
-        }
-        break;
-    case KBD_STATE_KSPECIAL:
-        if (scancode == 0xf0) { //release code
-            kbd_state.state = KBD_STATE_KRELEASED;       
-        } else {
+
+    switch (kbd_state.state) {
+        case KBD_STATE_KWAIT:
+            if (scancode == 0xf0) { // release code
+                kbd_state.state = KBD_STATE_KRELEASED;
+            } else if (scancode == 0xe0) {
+                kbd_state.state = KBD_STATE_KSPECIAL;
+                kbd_state.translation_table = scancode_set2_ex;
+            } else {
+                key = kbd_state.translation_table[scancode];
+                kbd_buffer_key_event(key, scancode, KBD_KEY_FPRESSED);
+            }
+            break;
+        case KBD_STATE_KSPECIAL:
+            if (scancode == 0x12) {
+                kbd_state.state = KBD_STATE_E012;
+            } else if (scancode == 0xf0) { // release code
+                kbd_state.state = KBD_STATE_KRELEASED_E0;
+            } else {
+                key = kbd_state.translation_table[scancode];
+                kbd_buffer_key_event(key, scancode, KBD_KEY_FPRESSED);
+
+                kbd_state.state = KBD_STATE_KWAIT;
+                kbd_state.translation_table = scancode_set2;
+            }
+            break;
+        // handle the '0xE0, 0x12, 0xE0, xx' sequence
+        case KBD_STATE_E012:
+            if (scancode == 0xe0) {
+                kbd_state.state = KBD_STATE_KSPECIAL;
+                kbd_state.translation_table = scancode_set2_ex;
+            }
+            break;
+        case KBD_STATE_KRELEASED_E0:
+            if (scancode == 0x12) {
+                goto escape_release;
+            }
+            // fall through
+        case KBD_STATE_KRELEASED:

             key = kbd_state.translation_table[scancode];
             key = kbd_state.translation_table[scancode];

-            kbd_buffer_key_event(key, scancode, KBD_KEY_FPRESSED);
+            kbd_buffer_key_event(key, scancode, KBD_KEY_FRELEASED);

 
 

+        escape_release:
+            // reset the translation table to scancode_set2

             kbd_state.state = KBD_STATE_KWAIT;
             kbd_state.translation_table = scancode_set2;
             kbd_state.state = KBD_STATE_KWAIT;
             kbd_state.translation_table = scancode_set2;

-        }
-        break;
-    case KBD_STATE_KRELEASED:
-        key = kbd_state.translation_table[scancode];
-        kbd_buffer_key_event(key, scancode, KBD_KEY_FRELEASED);
-        
-        // reset the translation table to scancode_set2
-        kbd_state.state = KBD_STATE_KWAIT;   
-        kbd_state.translation_table = scancode_set2;
-        break;
-    
-    default:
-        break;
+            break;
+
+        default:
+            break;

     }
 }
 
     }
 }
 

-static uint8_t ps2_issue_cmd(char cmd, uint16_t arg) {
+static u8_t
+ps2_issue_cmd(char cmd, u16_t arg)
+{

     ps2_post_cmd(PS2_PORT_CTRL_CMDREG, cmd, arg);
     ps2_post_cmd(PS2_PORT_CTRL_CMDREG, cmd, arg);

-    
+

     // 等待PS/2控制器返回。通过轮询（polling）状态寄存器的 bit 0
     // 如置位，则表明返回代码此时就在 0x60 IO口上等待读取。
     // 等待PS/2控制器返回。通过轮询（polling）状态寄存器的 bit 0
     // 如置位，则表明返回代码此时就在 0x60 IO口上等待读取。

-    while(!(io_inb(PS2_PORT_CTRL_STATUS) & PS2_STATUS_OFULL));
+    while (!(io_inb(PS2_PORT_CTRL_STATUS) & PS2_STATUS_OFULL))
+        ;

 
     return io_inb(PS2_PORT_ENC_CMDREG);
 }
 
 
     return io_inb(PS2_PORT_ENC_CMDREG);
 }
 

-static void ps2_post_cmd(uint8_t port, char cmd, uint16_t arg) {
+static u8_t
+ps2_issue_cmd_wretry(char cmd, u16_t arg)
+{
+    u8_t r, c = 0;
+    while ((r = ps2_issue_cmd(cmd, arg)) == PS2_RESULT_NAK && c < 5) {
+        c++;
+    }
+    if (c >= 5) {
+        kprintf(KWARN "max attempt reached.\n");
+    }
+    return r;
+}
+
+static void
+ps2_post_cmd(u8_t port, char cmd, u16_t arg)
+{

     // 等待PS/2输入缓冲区清空，这样我们才可以写入命令
     // 等待PS/2输入缓冲区清空，这样我们才可以写入命令

-    while(io_inb(PS2_PORT_CTRL_STATUS) & PS2_STATUS_IFULL);
+    while (io_inb(PS2_PORT_CTRL_STATUS) & PS2_STATUS_IFULL)
+        ;

 
     io_outb(port, cmd);
     io_delay(PS2_DELAY);
 
     io_outb(port, cmd);
     io_delay(PS2_DELAY);

-    
+

     if (!(arg & PS2_NO_ARG)) {
         // 所有参数一律通过0x60传入。
     if (!(arg & PS2_NO_ARG)) {
         // 所有参数一律通过0x60传入。

-        io_outb(PS2_PORT_ENC_CMDREG, (uint8_t)(arg & 0x00ff));
+        while (io_inb(PS2_PORT_CTRL_STATUS) & PS2_STATUS_IFULL)
+            ;
+        io_outb(PS2_PORT_ENC_CMDREG, (u8_t)(arg & 0x00ff));

         io_delay(PS2_DELAY);
     }
 }
 
         io_delay(PS2_DELAY);
     }
 }
 

-static uint8_t ps2_issue_dev_cmd(char cmd, uint16_t arg) {
+static u8_t
+ps2_issue_dev_cmd(char cmd, u16_t arg)
+{

     ps2_post_cmd(PS2_PORT_ENC_CMDREG, cmd, arg);
     ps2_post_cmd(PS2_PORT_ENC_CMDREG, cmd, arg);

-    
+

     // 等待PS/2控制器返回。通过轮询（polling）状态寄存器的 bit 0
     // 如置位，则表明返回代码此时就在 0x60 IO口上等待读取。
     // 等待PS/2控制器返回。通过轮询（polling）状态寄存器的 bit 0
     // 如置位，则表明返回代码此时就在 0x60 IO口上等待读取。

-    while(!(io_inb(PS2_PORT_CTRL_STATUS) & PS2_STATUS_OFULL));
+    while (!(io_inb(PS2_PORT_CTRL_STATUS) & PS2_STATUS_OFULL))
+        ;

 
     return io_inb(PS2_PORT_ENC_CMDREG);
 
     return io_inb(PS2_PORT_ENC_CMDREG);

-}
-
-int kbd_recv_key(struct kdb_keyinfo_pkt* key_event) {
-    if (!key_buf.buffered_len) {
-        return 0;
-    }
-    mutex_lock(&key_buf.mutex);
-
-    struct kdb_keyinfo_pkt* pkt_current = &key_buf.buffer[key_buf.read_ptr];
-
-    *key_event = *pkt_current;
-    key_buf.buffered_len--;
-    key_buf.read_ptr = (key_buf.read_ptr + 1) % PS2_KBD_RECV_BUFFER_SIZE;
-
-    mutex_unlock(&key_buf.mutex);
-    return 1;
-}
-
-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 is lagged so much such that the buffer is full.
-        // It is suggested to read from beginning for nearly up-to-date readings.
-        key_buf.read_ptr = 0;
-        key_buf.buffered_len = index;
-    }
-    else {
-        key_buf.buffered_len++;
-    }
-    return &key_buf.buffer[index];

 }
\ No newline at end of file
 }
\ No newline at end of file