update project struct & readme

[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 fc4151aa84ac0346e8908ad11d70e469061904c6..ae51dcf01ce38b9f540b81b26ba4c6cc11484fb7 100644 (file)
--- a/lunaix-os/kernel/peripheral/ps2kbd.c
+++ b/lunaix-os/kernel/peripheral/ps2kbd.c
@@ -3,14 +3,15 @@
 #include <lunaix/timer.h>
 #include <lunaix/common.h>
 #include <lunaix/syslog.h>
 #include <lunaix/timer.h>
 #include <lunaix/common.h>
 #include <lunaix/syslog.h>

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

 
 #include <hal/cpu.h>
 
 #include <hal/cpu.h>

-

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

-#include <stdint.h>

 #include <klibc/string.h>
 
 #include <klibc/string.h>
 

+#include <stdint.h>
+

 #define PS2_DEV_CMD_MAX_ATTEMPTS 5
 
 LOG_MODULE("PS2KBD");
 #define PS2_DEV_CMD_MAX_ATTEMPTS 5
 
 LOG_MODULE("PS2KBD");


@@ -68,20 +69,18 @@ static kbd_keycode_t scancode_set2_shift[] = {
 #define KBD_STATE_KWAIT         0x00
 #define KBD_STATE_KSPECIAL      0x01
 #define KBD_STATE_KRELEASED     0x02
 #define KBD_STATE_KWAIT         0x00
 #define KBD_STATE_KSPECIAL      0x01
 #define KBD_STATE_KRELEASED     0x02

-// #define KBD_STATE_CMDPROCS      0x80
+#define KBD_STATE_CMDPROCS      0x40

 
 void intr_ps2_kbd_handler(const isr_param* param);
 static struct kdb_keyinfo_pkt* ps2_keybuffer_next_write();
 
 // TODO: Abstract the bounded buffer out.
 void ps2_device_post_cmd(char cmd, char arg) {
 
 void intr_ps2_kbd_handler(const isr_param* param);
 static struct kdb_keyinfo_pkt* ps2_keybuffer_next_write();
 
 // TODO: Abstract the bounded buffer out.
 void ps2_device_post_cmd(char cmd, char arg) {

-    // 不需要任何的类似lock cmpxchgl的骚操作。
-    // 这条赋值表达式最多涉及一个内存引用（e.g., movl $1, (cmd_q.lock)），因此是原子的。
-    cmd_q.lock = 1;
+    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) {
         // 队列已满！
     int index = (cmd_q.queue_ptr + cmd_q.queue_len) % PS2_CMD_QUEUE_SIZE;
     if (index == cmd_q.queue_ptr && cmd_q.queue_len) {
         // 队列已满！

-        cmd_q.lock = 0;
+        mutex_unlock(&cmd_q.mutex);

         return;
     }
 
         return;
     }
 


@@ -91,7 +90,7 @@ void ps2_device_post_cmd(char cmd, char arg) {
     cmd_q.queue_len++;
 
     // 释放锁，同理。
     cmd_q.queue_len++;
 
     // 释放锁，同理。

-    cmd_q.lock = 0;
+    mutex_unlock(&cmd_q.mutex);

 }
 
 void ps2_kbd_init() {
 }
 
 void ps2_kbd_init() {


@@ -99,13 +98,37 @@ void ps2_kbd_init() {
     memset(&cmd_q, 0, sizeof(cmd_q));
     memset(&key_buf, 0, sizeof(key_buf));
     memset(&kbd_state, 0, sizeof(kbd_state));
     memset(&cmd_q, 0, sizeof(cmd_q));
     memset(&key_buf, 0, sizeof(key_buf));
     memset(&kbd_state, 0, sizeof(kbd_state));

+    
+    mutex_init(&cmd_q.mutex);
+    mutex_init(&key_buf.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;
 

+    acpi_context* acpi_ctx = acpi_get_context();
+    if (acpi_ctx->fadt.header.rev > 1) {
+        /*
+         *  只有当前ACPI版本大于1时，我们才使用FADT的IAPC_BOOT_ARCH去判断8042是否存在。
+         *  这是一个坑，在ACPI v1中，这个字段是reserved！而这及至APCI v2才出现。
+         *  需要注意：Bochs 和 QEMU 使用的是ACPI v1，而非 v2 （virtualbox好像是v4）
+         * 
+         *  请看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?
+            return;
+        }
+    }
+    else {
+        kprintf(KWARN "Outdated FADT used, assuming 8042 always exist.\n");
+    }
+    
+    

     cpu_disable_interrupt();
 
     cpu_disable_interrupt();
 

-    // XXX: 是否需要使用FADT探测PS/2控制器的存在？
-

     // 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);
     // 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);


@@ -150,6 +173,19 @@ void ps2_kbd_init() {
     //      因为我们需要保证isr尽量的简短，运行起来快速。而发送这些命令非常的耗时。
     timer_run_ms(5, ps2_process_cmd, NULL, TIMER_MODE_PERIODIC);
 
     //      因为我们需要保证isr尽量的简短，运行起来快速。而发送这些命令非常的耗时。
     timer_run_ms(5, ps2_process_cmd, NULL, TIMER_MODE_PERIODIC);
 

+    /*
+     *   一切准备就绪后，我们才教ioapic去启用IRQ#1。
+     *   至于为什么要在这里，原因是：初始化所使用的一些指令可能会导致IRQ#1的触发（因为返回码），或者是一些什么
+     *  情况导致IRQ#1的误触发（可能是未初始化导致IRQ#1线上不稳定）。于是这些IRQ#1会堆积在APIC的队列里（因为此时我们正在
+     *  初始化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);
+

 done:
     cpu_enable_interrupt();
 }
 done:
     cpu_enable_interrupt();
 }


@@ -163,11 +199,10 @@ void ps2_process_cmd(void* arg) {
     // 因此，我们这里仅仅进行判断。
     // 会不会产生指令堆积？不会，因为指令发送的频率远远低于指令队列清空的频率。在目前，我们发送的唯一指令
     // 就只是用来开关键盘上的LED灯（如CAPSLOCK）。
     // 因此，我们这里仅仅进行判断。
     // 会不会产生指令堆积？不会，因为指令发送的频率远远低于指令队列清空的频率。在目前，我们发送的唯一指令
     // 就只是用来开关键盘上的LED灯（如CAPSLOCK）。

-    if (!cmd_q.queue_len || cmd_q.lock) {
+    if (mutex_on_hold(&cmd_q.mutex) || !cmd_q.queue_len) {

         return;
     }
 
         return;
     }
 

-    // kbd_state.state |= KBD_STATE_CMDPROCS;

     // 处理队列排头的指令
     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];
     char result;


@@ -178,6 +213,7 @@ void ps2_process_cmd(void* arg) {
     // 则尝试最多五次
     do {
         result = ps2_issue_dev_cmd(pending_cmd->cmd, pending_cmd->arg);
     // 则尝试最多五次
     do {
         result = ps2_issue_dev_cmd(pending_cmd->cmd, pending_cmd->arg);

+        kbd_state.state += KBD_STATE_CMDPROCS;

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


@@ -207,7 +243,7 @@ void kbd_buffer_key_event(kbd_keycode_t key, uint8_t scancode, kbd_kstate_t stat
         state = state | kbd_state.key_state;
         key = key & (0xffdf | -('a' > key || key > 'z' || !(state & KBD_KEY_FCAPSLKED)));
 
         state = state | kbd_state.key_state;
         key = key & (0xffdf | -('a' > key || key > 'z' || !(state & KBD_KEY_FCAPSLKED)));
 

-        if (!key_buf.lock) {
+        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,
             struct kdb_keyinfo_pkt* keyevent_pkt = ps2_keybuffer_next_write();
             *keyevent_pkt = (struct kdb_keyinfo_pkt) {
                 .keycode = key,


@@ -242,22 +278,18 @@ void intr_ps2_kbd_handler(const isr_param* param) {
      * 那么当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:
+     * Problem 1 (Fixed):

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

+     * Solution:
+     *      累加掩码 ;)

      */
      */

-    // FIXME: Address Problem #1
-    // if ((kbd_state.state & KBD_STATE_CMDPROCS)) {
-    //     kbd_state.state &= ~KBD_STATE_CMDPROCS;
-    //     return;
-    // }
-
-    // 目前还是使用该方法。。。
-    if (scancode >= 0xfa) {
+    if ((kbd_state.state & 0xc0)) {
+        kbd_state.state -= KBD_STATE_CMDPROCS;

         return;
     }
     
         return;
     }
     

-    //kprintf(KINFO "%x\n", scancode & 0xff);
+    //kprintf(KDEBUG "%x\n", scancode & 0xff);

     
     switch (kbd_state.state)
     {
     
     switch (kbd_state.state)
     {


@@ -327,28 +359,29 @@ static void ps2_post_cmd(uint8_t port, char cmd, uint16_t arg) {
     while((result = io_inb(PS2_PORT_CTRL_STATUS)) & PS2_STATUS_IFULL);
 
     io_outb(port, cmd);
     while((result = io_inb(PS2_PORT_CTRL_STATUS)) & PS2_STATUS_IFULL);
 
     io_outb(port, cmd);

+    io_delay(PS2_DELAY);
+    

     if (!(arg & PS2_NO_ARG)) {
         // 所有参数一律通过0x60传入。
         io_outb(PS2_PORT_ENC_CMDREG, (uint8_t)(arg & 0x00ff));
     if (!(arg & PS2_NO_ARG)) {
         // 所有参数一律通过0x60传入。
         io_outb(PS2_PORT_ENC_CMDREG, (uint8_t)(arg & 0x00ff));

+        io_delay(PS2_DELAY);

     }
 }
 
     }
 }
 

-struct kdb_keyinfo_pkt* kbd_try_read_one() {
+int kbd_recv_key(struct kdb_keyinfo_pkt* key_event) {

     if (!key_buf.buffered_len) {
     if (!key_buf.buffered_len) {

-        return NULL;
+        return 0;

     }
     }

-    key_buf.lock = 1;
-    struct kdb_keyinfo_pkt* pkt_copy = 
-        (struct kdb_keyinfo_pkt*) lxmalloc(sizeof(struct kdb_keyinfo_pkt));
+    mutex_lock(&key_buf.mutex);

 
     struct kdb_keyinfo_pkt* pkt_current = &key_buf.buffer[key_buf.read_ptr];
 
 
     struct kdb_keyinfo_pkt* pkt_current = &key_buf.buffer[key_buf.read_ptr];
 

-    *pkt_copy = *pkt_current;
+    *key_event = *pkt_current;

     key_buf.buffered_len--;
     key_buf.read_ptr = (key_buf.read_ptr + 1) % PS2_KBD_RECV_BUFFER_SIZE;
 
     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;
+    mutex_unlock(&key_buf.mutex);
+    return 1;

 }
 
 static struct kdb_keyinfo_pkt* ps2_keybuffer_next_write() {
 }
 
 static struct kdb_keyinfo_pkt* ps2_keybuffer_next_write() {