lunaix-os/kernel/peripheral/ps2kbd.c

   1 #include <hal/acpi/acpi.h>
   2 #include <hal/ioapic.h>
   3 #include <lunaix/clock.h>
   4 #include <lunaix/common.h>
   5 #include <lunaix/input.h>
   6 #include <lunaix/isrm.h>
   7 #include <lunaix/peripheral/ps2kbd.h>
   8 #include <lunaix/syslog.h>
   9 #include <lunaix/timer.h>
  10
  11 #include <arch/i386/interrupts.h>
  12 #include <hal/cpu.h>
  13 #include <klibc/string.h>
  14
  15 #include <stdint.h>
  16
  17 #define PS2_DEV_CMD_MAX_ATTEMPTS 5
  18
  19 LOG_MODULE("i8042");
  20
  21 static struct ps2_cmd_queue cmd_q;
  22 static struct ps2_kbd_state kbd_state;
  23
  24 #define KEY_NUM(x) (x + 0x30)
  25 #define KEY_NPAD(x) ON_KEYPAD(KEY_NUM(x))
  26
  27 // 我们使用 Scancode Set 2
  28
  29 // clang-format off
  30
  31 // 大部分的扫描码（键码）
  32 static kbd_keycode_t scancode_set2[] = {
  33     0, KEY_F9, 0, KEY_F5, KEY_F3, KEY_F1, KEY_F2, KEY_F12, 0, KEY_F10, KEY_F8, KEY_F6,
  34     KEY_F4, KEY_HTAB, '`', 0, 0, KEY_LALT, KEY_LSHIFT, 0, KEY_LCTRL, 'q', KEY_NUM(1),
  35     0, 0, 0, 'z', 's', 'a', 'w', KEY_NUM(2), 0, 0, 'c', 'x', 'd', 'e', KEY_NUM(4), KEY_NUM(3),
  36     0, 0, KEY_SPACE, 'v', 'f', 't', 'r', KEY_NUM(5),
  37     0, 0, 'n', 'b', 'h', 'g', 'y', KEY_NUM(6), 0, 0, 0, 'm', 'j', 'u', KEY_NUM(7), KEY_NUM(8),
  38     0, 0, ',', 'k', 'i', 'o', KEY_NUM(0), KEY_NUM(9), 0, 0, '.', '/', 'l', ';', 'p', '-', 0, 0,
  39     0, '\'', 0, '[', '=', 0, 0, KEY_CAPSLK, KEY_RSHIFT, KEY_LF, ']', 0, '\\', 0, 0, 0, 0, 0, 0, 0,
  40     0, KEY_BS, 0, 0, KEY_NPAD(1), 0, KEY_NPAD(4), KEY_NPAD(7), 0, 0, 0, KEY_NPAD(0), ON_KEYPAD('.'),
  41     KEY_NPAD(2), KEY_NPAD(5), KEY_NPAD(6), KEY_NPAD(8), KEY_ESC, KEY_NUMSLK, KEY_F11, ON_KEYPAD('+'),
  42     KEY_NPAD(3), ON_KEYPAD('-'), ON_KEYPAD('*'), KEY_NPAD(9), KEY_SCRLLK, 0, 0, 0, 0, KEY_F7
  43 };
  44
  45 // 一些特殊的键码（以 0xe0 位前缀的）
  46 static kbd_keycode_t scancode_set2_ex[] = {
  47     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, KEY_RALT, 0, 0,
  48     KEY_RCTRL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  49     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  50     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ON_KEYPAD('/'), 0, 0, 0, 0, 0, 0, 0, 0,
  51     0, 0, 0, 0, 0, 0, 0, ON_KEYPAD(KEY_LF), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  52     KEY_END, 0, KEY_LEFT, KEY_HOME,
  53     0, 0, 0, KEY_INSERT, KEY_DELETE, KEY_DOWN, 0, KEY_RIGHT, KEY_UP, 0, 0,
  54     0, 0, KEY_PG_DOWN, 0, 0, KEY_PG_UP
  55 };
  56
  57 // 用于处理 Shift+<key> 的情况
  58 static kbd_keycode_t scancode_set2_shift[] = {
  59     0, KEY_F9, 0, KEY_F5, KEY_F3, KEY_F1, KEY_F2, KEY_F12, 0, KEY_F10, KEY_F8, KEY_F6,
  60     KEY_F4, KEY_HTAB, '~', 0, 0, KEY_LALT, KEY_LSHIFT, 0, KEY_LCTRL, 'Q', '!',
  61     0, 0, 0, 'Z', 'S', 'A', 'W', '@', 0, 0, 'C', 'X', 'D', 'E', '$', '#',
  62     0, 0, KEY_SPACE, 'V', 'F', 'T', 'R', '%',
  63     0, 0, 'N', 'B', 'H', 'G', 'Y', '^', 0, 0, 0, 'M', 'J', 'U', '&', '*',
  64     0, 0, '<', 'K', 'I', 'O', ')', '(', 0, 0, '>', '?', 'L', ':', 'P', '_', 0, 0,
  65     0, '"', 0, '{', '+', 0, 0, KEY_CAPSLK, KEY_RSHIFT, KEY_LF, '}', 0, '|', 0, 0, 0, 0, 0, 0, 0,
  66     0, KEY_BS, 0, 0, KEY_NPAD(1), 0, KEY_NPAD(4), KEY_NPAD(7), 0, 0, 0, KEY_NPAD(0), ON_KEYPAD('.'),
  67     KEY_NPAD(2), KEY_NPAD(5), KEY_NPAD(6), KEY_NPAD(8), KEY_ESC, KEY_NUMSLK, KEY_F11, ON_KEYPAD('+'),
  68     KEY_NPAD(3), ON_KEYPAD('-'), ON_KEYPAD('*'), KEY_SCRLLK, 0, 0, 0, 0, KEY_F7
  69 };
  70
  71 // clang-format on
  72
  73 static struct input_device* kbd_idev;
  74
  75 #define KBD_STATE_KWAIT 0x00
  76 #define KBD_STATE_KSPECIAL 0x01
  77 #define KBD_STATE_KRELEASED 0x02
  78 #define KBD_STATE_E012 0x03
  79 #define KBD_STATE_KRELEASED_E0 0x04
  80 #define KBD_STATE_CMDPROCS 0x40
  81
  82 // #define KBD_ENABLE_SPIRQ_FIX
  83 #define KBD_ENABLE_SPIRQ_FIX2
  84 // #define KBD_DBGLOG
  85
  86 void
  87 intr_ps2_kbd_handler(const isr_param* param);
  88
  89 static u8_t
  90 ps2_issue_cmd_wretry(char cmd, u16_t arg);
  91
  92 void
  93 ps2_device_post_cmd(char cmd, char arg)
  94 {
  95     mutex_lock(&cmd_q.mutex);
  96     int index = (cmd_q.queue_ptr + cmd_q.queue_len) % PS2_CMD_QUEUE_SIZE;
  97     if (index == cmd_q.queue_ptr && cmd_q.queue_len) {
  98         // 队列已满！
  99         mutex_unlock(&cmd_q.mutex);
 100         return;
 101     }
 102
 103     struct ps2_cmd* container = &cmd_q.cmd_queue[index];
 104     container->cmd = cmd;
 105     container->arg = arg;
 106     cmd_q.queue_len++;
 107
 108     // 释放锁，同理。
 109     mutex_unlock(&cmd_q.mutex);
 110 }
 111
 112 void
 113 ps2_kbd_init()
 114 {
 115
 116     memset(&cmd_q, 0, sizeof(cmd_q));
 117     memset(&kbd_state, 0, sizeof(kbd_state));
 118
 119     mutex_init(&cmd_q.mutex);
 120
 121     kbd_state.translation_table = scancode_set2;
 122     kbd_state.state = KBD_STATE_KWAIT;
 123
 124     kbd_idev = input_add_device("i8042-kbd");
 125
 126     acpi_context* acpi_ctx = acpi_get_context();
 127     if (acpi_ctx->fadt.header.rev > 1) {
 128         /*
 129          *  只有当前ACPI版本大于1时，我们才使用FADT的IAPC_BOOT_ARCH去判断8042是否存在。
 130          *  这是一个坑，在ACPI v1中，这个字段是reserved！而这及至ACPI v2才出现。
 131          *  需要注意：Bochs 和 QEMU 使用的是ACPI v1，而非 v2
 132          * （virtualbox好像是v4）
 133          *
 134          *  (2022/6/29)
 135          *  QEMU在7.0.0版本中，修复了FADT::IAPC_BOOT无法正确提供关于i8042的信息的bug
 136          *      https://wiki.qemu.org/ChangeLog/7.0#ACPI_.2F_SMBIOS
 137          *
 138          *  请看Bochs的bios源码（QEMU的BIOS其实是照抄bochs的，所以也是一个德行。。）：
 139          *      https://bochs.sourceforge.io/cgi-bin/lxr/source/bios/rombios32.c#L1314
 140          */
 141         if (!(acpi_ctx->fadt.boot_arch & IAPC_ARCH_8042)) {
 142             kprintf(KERROR "not found\n");
 143             // FUTURE: Some alternative fallback on this? Check PCI bus for USB
 144             // controller instead?
 145             return;
 146         }
 147     } else {
 148         kprintf(KWARN "outdated FADT used, assuming exists.\n");
 149     }
 150
 151     char result;
 152
 153     cpu_disable_interrupt();
 154
 155     // 1、禁用任何的PS/2设备
 156     ps2_post_cmd(PS2_PORT_CTRL_CMDREG, PS2_CMD_PORT1_DISABLE, PS2_NO_ARG);
 157     ps2_post_cmd(PS2_PORT_CTRL_CMDREG, PS2_CMD_PORT2_DISABLE, PS2_NO_ARG);
 158
 159     // 2、清空控制器缓冲区
 160     io_inb(PS2_PORT_ENC_DATA);
 161
 162     // 3、屏蔽所有PS/2设备（端口1&2）IRQ，并且禁用键盘键码转换功能
 163     result = ps2_issue_cmd(PS2_CMD_READ_CFG, PS2_NO_ARG);
 164     result = result & ~(PS2_CFG_P1INT | PS2_CFG_P2INT);
 165     ps2_post_cmd(PS2_PORT_CTRL_CMDREG, PS2_CMD_WRITE_CFG, result);
 166
 167     // 4、控制器自检
 168     result = ps2_issue_cmd_wretry(PS2_CMD_SELFTEST, PS2_NO_ARG);
 169     if (result != PS2_RESULT_TEST_OK) {
 170         kprintf(KWARN "controller self-test failed. (%x)\n", result);
 171         // goto done;
 172     }
 173
 174     // 5、设备自检（端口1自检，通常是我们的键盘）
 175     result = ps2_issue_cmd_wretry(PS2_CMD_SELFTEST_PORT1, PS2_NO_ARG);
 176     if (result != 0) {
 177         kprintf(KERROR "interface test on port 1 failed. (%x)\n", result);
 178         // goto done;
 179     }
 180
 181     ps2_post_cmd(PS2_PORT_CTRL_CMDREG, PS2_CMD_PORT2_DISABLE, PS2_NO_ARG);
 182
 183     // 6、开启位于端口1的 IRQ，并启用端口1。不用理会端口2，那儿一般是鼠标。
 184     ps2_post_cmd(PS2_PORT_CTRL_CMDREG, PS2_CMD_PORT1_ENABLE, PS2_NO_ARG);
 185     result = ps2_issue_cmd(PS2_CMD_READ_CFG, PS2_NO_ARG);
 186     // 重新设置配置字节，因为控制器自检有可能重置我们先前做的改动。
 187     result = (result | PS2_CFG_P1INT) & ~(PS2_CFG_TRANSLATION | PS2_CFG_P2INT);
 188     ps2_post_cmd(PS2_PORT_CTRL_CMDREG, PS2_CMD_WRITE_CFG, result);
 189
 190     // 至此，PS/2控制器和设备已完成初始化，可以正常使用。
 191
 192     // 搞一个计时器，将我们的 ps2_process_cmd
 193     // 挂上去。每隔5毫秒执行排在队头的命令。
 194     //  为什么只执行队头的命令，而不是全部的命令？
 195     //      因为我们需要保证isr尽量的简短，运行起来快速。而发送这些命令非常的耗时。
 196     timer_run_ms(5, ps2_process_cmd, NULL, TIMER_MODE_PERIODIC);
 197
 198     /*
 199      *   一切准备就绪后，我们才教ioapic去启用IRQ#1。
 200      *   至于为什么要在这里，原因是：初始化所使用的一些指令可能会导致IRQ#1的触发（因为返回码），或者是一些什么
 201      *  情况导致IRQ#1的误触发（可能是未初始化导致IRQ#1线上不稳定）。于是这些IRQ#1会堆积在APIC的队列里（因为此时我们正在
 202      *  初始化8042，屏蔽了所有中断，IF=0）。
 203      *  当sti后，这些堆积的中断会紧跟着递送进CPU里，导致我们的键盘handler误认为由按键按下，从而将这个毫无意义的数值加入
 204      *  我们的队列中，以供上层读取。
 205      *
 206      *  所以，保险的方法是：在初始化后才去设置ioapic，这样一来我们就能有一个稳定的IRQ#1以放心使用。
 207      */
 208     isrm_bindirq(PC_AT_IRQ_KBD, intr_ps2_kbd_handler);
 209
 210     cpu_enable_interrupt();
 211 }
 212
 213 void
 214 ps2_process_cmd(void* arg)
 215 {
 216     /*
 217      * 检查锁是否已被启用，如果启用，则表明该timer中断发生时，某个指令正在入队。
 218      * 如果是这种情况则跳过，留到下一轮再尝试处理。
 219      * 注意，这里其实是ISR的一部分（timer中断），对于单核CPU来说，ISR等同于单个的原子操作。
 220      * （因为EFLAGS.IF=0，所有可屏蔽中断被屏蔽。对于NMI的情况，那么就直接算是triple
 221      * fault了，所以也没有讨论的意义）
 222      * 所以，假若我们遵从互斥锁的严格定义（即这里需要阻塞），那么中断将会被阻塞，进而造成死锁。
 223      * 因此，我们这里仅仅进行判断。
 224      * 会不会产生指令堆积？不会，因为指令发送的频率远远低于指令队列清空的频率。在目前，我们发送的唯一指令
 225      * 就只是用来开关键盘上的LED灯（如CAPSLOCK）。
 226      */
 227     if (mutex_on_hold(&cmd_q.mutex) || !cmd_q.queue_len) {
 228         return;
 229     }
 230
 231     // 处理队列排头的指令
 232     struct ps2_cmd* pending_cmd = &cmd_q.cmd_queue[cmd_q.queue_ptr];
 233     u8_t result;
 234     int attempts = 0;
 235
 236     // 尝试将命令发送至PS/2键盘（通过PS/2控制器）
 237     // 如果不成功（0x60 IO口返回 0xfe，即 NAK i.e. Resend）
 238     // 则尝试最多五次
 239     do {
 240         result = ps2_issue_dev_cmd(pending_cmd->cmd, pending_cmd->arg);
 241 #ifdef KBD_ENABLE_SPIRQ_FIX
 242         kbd_state.state += KBD_STATE_CMDPROCS;
 243 #endif
 244         attempts++;
 245     } while (result == PS2_RESULT_NAK && attempts < PS2_DEV_CMD_MAX_ATTEMPTS);
 246     // XXX: 是否需要处理不成功的指令？
 247
 248     cmd_q.queue_ptr = (cmd_q.queue_ptr + 1) % PS2_CMD_QUEUE_SIZE;
 249     cmd_q.queue_len--;
 250 }
 251
 252 void
 253 kbd_buffer_key_event(kbd_keycode_t key, u8_t scancode, kbd_kstate_t state)
 254 {
 255     /*
 256         forgive me on these ugly bit-level tricks,
 257         I really hate doing branching on these "fliping switch" things
 258     */
 259     if (key == KEY_CAPSLK) {
 260         kbd_state.key_state ^= KBD_KEY_FCAPSLKED & -state;
 261     } else if (key == KEY_NUMSLK) {
 262         kbd_state.key_state ^= KBD_KEY_FNUMBLKED & -state;
 263     } else if (key == KEY_SCRLLK) {
 264         kbd_state.key_state ^= KBD_KEY_FSCRLLKED & -state;
 265     } else {
 266         if ((key & MODIFR)) {
 267             kbd_kstate_t tmp = (KBD_KEY_FLSHIFT_HELD << (key & 0x00ff));
 268             kbd_state.key_state = (kbd_state.key_state & ~tmp) | (tmp & -state);
 269         } else if (!(key & 0xff00) &&
 270                    (kbd_state.key_state &
 271                     (KBD_KEY_FLSHIFT_HELD | KBD_KEY_FRSHIFT_HELD))) {
 272             key = scancode_set2_shift[scancode];
 273         }
 274         state = state | kbd_state.key_state;
 275         key = key & (0xffdf |
 276                      -('a' > key || key > 'z' || !(state & KBD_KEY_FCAPSLKED)));
 277
 278         struct input_evt_pkt ipkt = { .pkt_type = (state & KBD_KEY_FPRESSED)
 279                                                     ? PKT_PRESS
 280                                                     : PKT_RELEASE,
 281                                       .scan_code = scancode,
 282                                       .sys_code = (state << 16) | key };
 283
 284         input_fire_event(kbd_idev, &ipkt);
 285
 286         return;
 287     }
 288
 289     if (state & KBD_KEY_FPRESSED) {
 290         // Ooops, this guy generates irq!
 291         ps2_device_post_cmd(PS2_KBD_CMD_SETLED,
 292                             (kbd_state.key_state >> 1) & 0x00ff);
 293     }
 294 }
 295
 296 void
 297 intr_ps2_kbd_handler(const isr_param* param)
 298 {
 299
 300     // This is important! Don't believe me? try comment it out and run on Bochs!
 301     // while (!(io_inb(PS2_PORT_CTRL_STATUS) & PS2_STATUS_OFULL))
 302     //    ;
 303
 304     // I know you are tempting to move this chunk after the keyboard state
 305     // check. But DO NOT. This chunk is in right place and right order. Moving
 306     // it at your own risk This is to ensure we've cleared the output buffer
 307     // everytime, so it won't pile up across irqs.
 308     u8_t scancode = io_inb(PS2_PORT_ENC_DATA);
 309     kbd_keycode_t key;
 310
 311     /*
 312      *    判断键盘是否处在指令发送状态，防止误触发。（伪输入中断）
 313      * 这是因为我们需要向ps/2设备发送指令（比如控制led灯），而指令会有返回码。
 314      * 这就会有可能导致ps/2控制器在受到我们的命令后（在ps2_process_cmd中），
 315      * 产生IRQ#1中断（虽然说这种情况取决于底层BIOS实现，但还是会发生，比如QEMU和bochs）。
 316      * 所以这就是说，当IRQ#1中断产生时，我们的CPU正处在另一个ISR中。这样就会导致所有的外部中断被缓存在APIC内部的
 317      * FIFO队列里，进行排队等待（APIC长度为二的队列 {IRR, TMR}；参考 Intel
 318      * Manual Vol.3A 10.8.4）
 319      * 那么当ps2_process_cmd执行完后（内嵌在#APIC_TIMER_IV），CPU返回EOI给APIC，APIC紧接着将排在队里的IRQ#1发送给CPU
 320      * 造成误触发。也就是说，我们此时读入的scancode实则上是上一个指令的返回代码。
 321      *
 322      * Problem 1 (Fixed):
 323      *      但是这种方法有个问题，那就是，假若我们的某一个命令失败了一次，ps/2给出0xfe，我们重传，ps/2收到指令并给出0xfa。
 324      *  那么这样一来，将会由两个连续的IRQ#1产生。而APIC是最多可以缓存两个IRQ，于是我们就会漏掉一个IRQ，依然会误触发。
 325      * Solution:
 326      *      累加掩码 ;)
 327      *
 328      * Problem 2:
 329      *    +
 330      * 这种累加掩码的操作是基于只有一号IRQ产生的中断的假设，万一中间夹杂了别的中断？Race
 331      * Condition!
 332      *    +
 333      * 不很稳定x1，假如连续4次发送失败，那么就会导致累加的掩码上溢出，从而导致下述判断失败。
 334      */
 335 #ifdef KBD_ENABLE_SPIRQ_FIX
 336     if ((kbd_state.state & 0xc0)) {
 337         kbd_state.state -= KBD_STATE_CMDPROCS;
 338
 339         return;
 340     }
 341 #endif
 342
 343 #ifdef KBD_ENABLE_SPIRQ_FIX2
 344     if (scancode == PS2_RESULT_ACK || scancode == PS2_RESULT_NAK) {
 345         return;
 346     }
 347 #endif
 348
 349 #ifdef KBD_DBGLOG
 350     kprintf(KDEBUG "%x\n", scancode & 0xff);
 351 #endif
 352
 353     switch (kbd_state.state) {
 354         case KBD_STATE_KWAIT:
 355             if (scancode == 0xf0) { // release code
 356                 kbd_state.state = KBD_STATE_KRELEASED;
 357             } else if (scancode == 0xe0) {
 358                 kbd_state.state = KBD_STATE_KSPECIAL;
 359                 kbd_state.translation_table = scancode_set2_ex;
 360             } else {
 361                 key = kbd_state.translation_table[scancode];
 362                 kbd_buffer_key_event(key, scancode, KBD_KEY_FPRESSED);
 363             }
 364             break;
 365         case KBD_STATE_KSPECIAL:
 366             if (scancode == 0x12) {
 367                 kbd_state.state = KBD_STATE_E012;
 368             } else if (scancode == 0xf0) { // release code
 369                 kbd_state.state = KBD_STATE_KRELEASED_E0;
 370             } else {
 371                 key = kbd_state.translation_table[scancode];
 372                 kbd_buffer_key_event(key, scancode, KBD_KEY_FPRESSED);
 373
 374                 kbd_state.state = KBD_STATE_KWAIT;
 375                 kbd_state.translation_table = scancode_set2;
 376             }
 377             break;
 378         // handle the '0xE0, 0x12, 0xE0, xx' sequence
 379         case KBD_STATE_E012:
 380             if (scancode == 0xe0) {
 381                 kbd_state.state = KBD_STATE_KSPECIAL;
 382                 kbd_state.translation_table = scancode_set2_ex;
 383             }
 384             break;
 385         case KBD_STATE_KRELEASED_E0:
 386             if (scancode == 0x12) {
 387                 goto escape_release;
 388             }
 389             // fall through
 390         case KBD_STATE_KRELEASED:
 391             key = kbd_state.translation_table[scancode];
 392             kbd_buffer_key_event(key, scancode, KBD_KEY_FRELEASED);
 393
 394         escape_release:
 395             // reset the translation table to scancode_set2
 396             kbd_state.state = KBD_STATE_KWAIT;
 397             kbd_state.translation_table = scancode_set2;
 398             break;
 399
 400         default:
 401             break;
 402     }
 403 }
 404
 405 static u8_t
 406 ps2_issue_cmd(char cmd, u16_t arg)
 407 {
 408     ps2_post_cmd(PS2_PORT_CTRL_CMDREG, cmd, arg);
 409
 410     // 等待PS/2控制器返回。通过轮询（polling）状态寄存器的 bit 0
 411     // 如置位，则表明返回代码此时就在 0x60 IO口上等待读取。
 412     while (!(io_inb(PS2_PORT_CTRL_STATUS) & PS2_STATUS_OFULL))
 413         ;
 414
 415     return io_inb(PS2_PORT_ENC_CMDREG);
 416 }
 417
 418 static u8_t
 419 ps2_issue_cmd_wretry(char cmd, u16_t arg)
 420 {
 421     u8_t r, c = 0;
 422     while ((r = ps2_issue_cmd(cmd, arg)) == PS2_RESULT_NAK && c < 5) {
 423         c++;
 424     }
 425     if (c >= 5) {
 426         kprintf(KWARN "max attempt reached.\n");
 427     }
 428     return r;
 429 }
 430
 431 static void
 432 ps2_post_cmd(u8_t port, char cmd, u16_t arg)
 433 {
 434     // 等待PS/2输入缓冲区清空，这样我们才可以写入命令
 435     while (io_inb(PS2_PORT_CTRL_STATUS) & PS2_STATUS_IFULL)
 436         ;
 437
 438     io_outb(port, cmd);
 439     io_delay(PS2_DELAY);
 440
 441     if (!(arg & PS2_NO_ARG)) {
 442         // 所有参数一律通过0x60传入。
 443         while (io_inb(PS2_PORT_CTRL_STATUS) & PS2_STATUS_IFULL)
 444             ;
 445         io_outb(PS2_PORT_ENC_CMDREG, (u8_t)(arg & 0x00ff));
 446         io_delay(PS2_DELAY);
 447     }
 448 }
 449
 450 static u8_t
 451 ps2_issue_dev_cmd(char cmd, u16_t arg)
 452 {
 453     ps2_post_cmd(PS2_PORT_ENC_CMDREG, cmd, arg);
 454
 455     // 等待PS/2控制器返回。通过轮询（polling）状态寄存器的 bit 0
 456     // 如置位，则表明返回代码此时就在 0x60 IO口上等待读取。
 457     while (!(io_inb(PS2_PORT_CTRL_STATUS) & PS2_STATUS_OFULL))
 458         ;
 459
 460     return io_inb(PS2_PORT_ENC_CMDREG);
 461 }