lunaix-os/kernel/peripheral/ps2kbd.c

   1 #include <lunaix/peripheral/ps2kbd.h>
   2 #include <lunaix/clock.h>
   3 #include <lunaix/timer.h>
   4 #include <lunaix/common.h>
   5 #include <lunaix/syslog.h>
   6 #include <lunaix/mm/kalloc.h>
   7
   8 #include <hal/cpu.h>
   9 #include <hal/ioapic.h>
  10
  11 #include <arch/x86/interrupts.h>
  12 #include <stdint.h>
  13 #include <klibc/string.h>
  14
  15 #define PS2_DEV_CMD_MAX_ATTEMPTS 5
  16
  17 LOG_MODULE("PS2KBD");
  18
  19 static struct ps2_cmd_queue cmd_q;
  20 static struct ps2_key_buffer key_buf;
  21 static struct ps2_kbd_state kbd_state;
  22
  23 #define KEY_NUM(x)      (x + 0x30)
  24 #define KEY_NPAD(x)      ON_KEYPAD(KEY_NUM(x))
  25
  26 // 我们使用 Scancode Set 2
  27
  28 // 大部分的扫描码（键码）
  29 static kbd_keycode_t scancode_set2[] = {
  30     0, KEY_F9, 0, KEY_F5, KEY_F3, KEY_F1, KEY_F2, KEY_F12, 0, KEY_F10, KEY_F8, KEY_F6,
  31     KEY_F4, KEY_HTAB, '`', 0, 0, KEY_LALT, KEY_LSHIFT, 0, KEY_LCTRL, 'q', KEY_NUM(1),
  32     0, 0, 0, 'z', 's', 'a', 'w', KEY_NUM(2), 0, 0, 'c', 'x', 'd', 'e', KEY_NUM(4), KEY_NUM(3),
  33     0, 0, KEY_SPACE, 'v', 'f', 't', 'r', KEY_NUM(5),
  34     0, 0, 'n', 'b', 'h', 'g', 'y', KEY_NUM(6), 0, 0, 0, 'm', 'j', 'u', KEY_NUM(7), KEY_NUM(8),
  35     0, 0, ',', 'k', 'i', 'o', KEY_NUM(0), KEY_NUM(9), 0, 0, '.', '/', 'l', ';', 'p', '-', 0, 0,
  36     0, '\'', 0, '[', '=', 0, 0, KEY_CAPSLK, KEY_RSHIFT, KEY_LF, ']', 0, '\\', 0, 0, 0, 0, 0, 0, 0,
  37     0, KEY_BS, 0, 0, KEY_NPAD(1), 0, KEY_NPAD(4), KEY_NPAD(7), 0, 0, 0, KEY_NPAD(0), ON_KEYPAD('.'),
  38     KEY_NPAD(2), KEY_NPAD(5), KEY_NPAD(6), KEY_NPAD(8), KEY_ESC, KEY_NUMSLK, KEY_F11, ON_KEYPAD('+'),
  39     KEY_NPAD(3), ON_KEYPAD('-'), ON_KEYPAD('*'), KEY_NPAD(9), KEY_SCRLLK, 0, 0, 0, 0, KEY_F7
  40 };
  41
  42 // 一些特殊的键码（以 0xe0 位前缀的）
  43 static kbd_keycode_t scancode_set2_ex[] = {
  44     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, KEY_RALT, 0, 0,
  45     KEY_RCTRL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  46     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  47     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ON_KEYPAD('/'), 0, 0, 0, 0, 0, 0, 0, 0,
  48     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,
  49     KEY_END, 0, KEY_LEFT, KEY_HOME,
  50     0, 0, 0, KEY_INSERT, KEY_DELETE, KEY_DOWN, 0, KEY_RIGHT, KEY_UP, 0, 0,
  51     0, 0, KEY_PG_DOWN, 0, 0, KEY_PG_UP
  52 };
  53
  54 // 用于处理 Shift+<key> 的情况
  55 static kbd_keycode_t scancode_set2_shift[] = {
  56     0, KEY_F9, 0, KEY_F5, KEY_F3, KEY_F1, KEY_F2, KEY_F12, 0, KEY_F10, KEY_F8, KEY_F6,
  57     KEY_F4, KEY_HTAB, '~', 0, 0, KEY_LALT, KEY_LSHIFT, 0, KEY_LCTRL, 'Q', '!',
  58     0, 0, 0, 'Z', 'S', 'A', 'W', '@', 0, 0, 'C', 'X', 'D', 'E', '$', '#',
  59     0, 0, KEY_SPACE, 'V', 'F', 'T', 'R', '%',
  60     0, 0, 'N', 'B', 'H', 'G', 'Y', '^', 0, 0, 0, 'M', 'J', 'U', '&', '*',
  61     0, 0, '<', 'K', 'I', 'O', ')', '(', 0, 0, '>', '?', 'L', ':', 'P', '_', 0, 0,
  62     0, '"', 0, '{', '+', 0, 0, KEY_CAPSLK, KEY_RSHIFT, KEY_LF, '}', 0, '|', 0, 0, 0, 0, 0, 0, 0,
  63     0, KEY_BS, 0, 0, KEY_NPAD(1), 0, KEY_NPAD(4), KEY_NPAD(7), 0, 0, 0, KEY_NPAD(0), ON_KEYPAD('.'),
  64     KEY_NPAD(2), KEY_NPAD(5), KEY_NPAD(6), KEY_NPAD(8), KEY_ESC, KEY_NUMSLK, KEY_F11, ON_KEYPAD('+'),
  65     KEY_NPAD(3), ON_KEYPAD('-'), ON_KEYPAD('*'), KEY_SCRLLK, 0, 0, 0, 0, KEY_F7
  66 };
  67
  68
  69 #define KBD_STATE_WAIT_KEY 0
  70 #define KBD_STATE_SPECIAL 1
  71 #define KBD_STATE_RELEASED 2
  72
  73 void intr_ps2_kbd_handler(const isr_param* param);
  74
  75 void ps2_device_post_cmd(char cmd, char arg) {
  76     // 不需要任何的类似lock cmpxchgl的骚操作。
  77     // 这条赋值表达式最多涉及一个内存引用（e.g., movl $1, (cmd_q.lock)），因此是原子的。
  78     cmd_q.lock = 1;
  79     int index = (cmd_q.queue_ptr + cmd_q.queue_len) % PS2_CMD_QUEUE_SIZE;
  80     int diff = index - cmd_q.queue_ptr;
  81     if (diff > 0 && diff != cmd_q.queue_len) {
  82         // 队列已满！
  83         return;
  84     }
  85
  86     struct ps2_cmd *container = &cmd_q.cmd_queue[index];
  87     container->cmd = cmd;
  88     container->arg = arg;
  89     cmd_q.queue_len++;
  90
  91     // 释放锁，同理。
  92     cmd_q.lock = 0;
  93 }
  94
  95 void ps2_kbd_init() {
  96
  97     memset(&cmd_q, 0, sizeof(cmd_q));
  98     memset(&key_buf, 0, sizeof(key_buf));
  99     memset(&kbd_state, 0, sizeof(kbd_state));
 100     kbd_state.translation_table = scancode_set2;
 101     kbd_state.state = KBD_STATE_WAIT_KEY;
 102
 103     cpu_disable_interrupt();
 104
 105     // XXX: 是否需要使用FADT探测PS/2控制器的存在？
 106
 107     // 1、禁用任何的PS/2设备
 108     ps2_post_cmd(PS2_PORT_CTRL_CMDREG, PS2_CMD_PORT1_DISABLE, PS2_NO_ARG);
 109     ps2_post_cmd(PS2_PORT_CTRL_CMDREG, PS2_CMD_PORT2_DISABLE, PS2_NO_ARG);
 110
 111     // 2、清空控制器缓冲区
 112     io_inb(PS2_PORT_ENC_DATA);
 113
 114     char result;
 115
 116     // 3、屏蔽所有PS/2设备（端口1&2）IRQ，并且禁用键盘键码转换功能
 117     result = ps2_issue_cmd(PS2_CMD_READ_CFG, PS2_NO_ARG);
 118     result = result & ~(PS2_CFG_P1INT | PS2_CFG_P2INT | PS2_CFG_TRANSLATION);
 119     ps2_post_cmd(PS2_PORT_CTRL_CMDREG, PS2_CMD_WRITE_CFG, result);
 120
 121     // 4、控制器自检
 122     result = ps2_issue_cmd(PS2_CMD_SELFTEST, PS2_NO_ARG);
 123     if (result != PS2_RESULT_TEST_OK) {
 124         kprintf(KERROR "Controller self-test failed.");
 125         goto done;
 126     }
 127
 128     // 5、设备自检（端口1自检，通常是我们的键盘）
 129     result = ps2_issue_cmd(PS2_CMD_SELFTEST_PORT1, PS2_NO_ARG);
 130     if (result != 0) {
 131         kprintf(KERROR "Interface test on port 1 failed.");
 132         goto done;
 133     }
 134
 135     // 6、开启位于端口1的 IRQ，并启用端口1。不用理会端口2，那儿一般是鼠标。
 136     ps2_post_cmd(PS2_PORT_CTRL_CMDREG, PS2_CMD_PORT1_ENABLE, PS2_NO_ARG);
 137     result = ps2_issue_cmd(PS2_CMD_READ_CFG, PS2_NO_ARG);
 138     result = result | PS2_CFG_P1INT;
 139     ps2_post_cmd(PS2_PORT_CTRL_CMDREG, PS2_CMD_WRITE_CFG, result);
 140
 141     // 至此，PS/2控制器和设备已完成初始化，可以正常使用。
 142
 143     // 将我们的键盘驱动挂载到第204号中断上（已由IOAPIC映射至IRQ#1），
 144     intr_subscribe(PC_KBD_IV, intr_ps2_kbd_handler);
 145
 146     // 搞一个计时器，将我们的 ps2_process_cmd 挂上去。每隔5毫秒执行排在队头的命令。
 147     //  为什么只执行队头的命令，而不是全部的命令？
 148     //      因为我们需要保证isr尽量的简短，运行起来快速。而发送这些命令非常的耗时。
 149     timer_run_ms(5, ps2_process_cmd, NULL, TIMER_MODE_PERIODIC);
 150
 151 done:
 152     cpu_enable_interrupt();
 153 }
 154
 155 void ps2_process_cmd(void* arg) {
 156     // 检查锁是否已被启用，如果启用，则表明该timer中断发生时，某个指令正在入队。
 157     // 如果是这种情况则跳过，留到下一轮再尝试处理。
 158     // 注意，这里其实是ISR的一部分（timer中断），对于单核CPU来说，ISR等同于单个的原子操作。
 159     // （因为EFLAGS.IF=0，所有可屏蔽中断被屏蔽。对于NMI的情况，那么就直接算是triple fault了，所以也没有讨论的意义）
 160     // 所以，假若我们遵从互斥锁的严格定义（即这里需要阻塞），那么中断将会被阻塞，进而造成死锁。
 161     // 因此，我们这里仅仅进行判断。
 162     // 会不会产生指令堆积？不会，因为指令发送的频率远远低于指令队列清空的频率。在目前，我们发送的唯一指令
 163     // 就只是用来开关键盘上的LED灯（如CAPSLOCK）。
 164     if (!cmd_q.queue_len || cmd_q.lock) {
 165         return;
 166     }
 167
 168     // 处理队列排头的指令
 169     struct ps2_cmd *pending_cmd = &cmd_q.cmd_queue[cmd_q.queue_ptr];
 170     char result;
 171     int attempts = 0;
 172
 173     // 尝试将命令发送至PS/2键盘（通过PS/2控制器）
 174     // 如果不成功（0x60 IO口返回 0xfe，即 NAK 或 Resend）
 175     // 则尝试最多五次
 176     do {
 177         result = ps2_issue_dev_cmd(pending_cmd->cmd, pending_cmd->arg);
 178         attempts++;
 179     } while(result == PS2_RESULT_NAK && attempts < PS2_DEV_CMD_MAX_ATTEMPTS);
 180
 181     // XXX: 是否需要处理不成功的指令？
 182
 183     cmd_q.queue_ptr = (cmd_q.queue_ptr + 1) % PS2_CMD_QUEUE_SIZE;
 184     cmd_q.queue_len--;
 185 }
 186
 187 static struct kdb_keyinfo_pkt* ps2_keybuffer_next_write() {
 188     int index = (key_buf.read_ptr + key_buf.buffered_len) % PS2_KBD_RECV_BUFFER_SIZE;
 189     if (index == key_buf.read_ptr && key_buf.buffered_len) {
 190         // the reader lagged so much. It is suggested to read from beginning.
 191         key_buf.read_ptr = 0;
 192         key_buf.buffered_len = index;
 193     }
 194     else {
 195         key_buf.buffered_len++;
 196     }
 197     return &key_buf.buffer[index];
 198 }
 199
 200 void kbd_buffer_key_event(kbd_keycode_t key, uint8_t scancode, kbd_kstate_t state) {
 201     // forgive me on these ugly bit-level tricks,
 202     // I really hate doing branching on these "fliping switch" things
 203     if (key == KEY_CAPSLK) {
 204         kbd_state.key_state ^= KBD_KEY_FCAPSLKED & -state;
 205     } else if (key == KEY_NUMSLK) {
 206         kbd_state.key_state ^= KBD_KEY_FNUMBLKED & -state;
 207     } else if (key == KEY_SCRLLK) {
 208         kbd_state.key_state ^= KBD_KEY_FSCRLLKED & -state;
 209     } else {
 210         if ((key & MODIFR)) {
 211             kbd_kstate_t tmp = (KBD_KEY_FLSHIFT_HELD << (key & 0x00ff));
 212             kbd_state.key_state = (kbd_state.key_state & ~tmp) | (tmp & -state);
 213         }
 214         else if (!(key & 0xff00) && (kbd_state.key_state & (KBD_KEY_FLSHIFT_HELD | KBD_KEY_FRSHIFT_HELD))) {
 215             key = scancode_set2_shift[scancode];
 216         }
 217         state = state | kbd_state.key_state;
 218         key = key & (0xffdf | -('a' > key || key > 'z' || !(state & KBD_KEY_FCAPSLKED)));
 219         time_t timestamp = clock_systime();
 220         // TODO: Construct the packet.
 221         if (!key_buf.lock) {
 222             struct kdb_keyinfo_pkt* keyevent_pkt = ps2_keybuffer_next_write();
 223             keyevent_pkt->keycode = key;
 224             keyevent_pkt->scancode = scancode;
 225             keyevent_pkt->state = state;
 226             keyevent_pkt->timestamp = timestamp;
 227         }
 228
 229         // kprintf(KDEBUG "%c (t=%d, s=%x, c=%d)\n", key & 0x00ff, timestamp, state, key >> 8);
 230         return; // do not delete this return
 231     }
 232
 233     // Ooops, this guy generates irq!
 234     ps2_device_post_cmd(PS2_KBD_CMD_SETLED, (kbd_state.key_state >> 1) & 0x00ff);
 235 }
 236
 237 void intr_ps2_kbd_handler(const isr_param* param) {
 238     uint8_t scancode = io_inb(PS2_PORT_ENC_DATA) & 0xff;
 239     kbd_keycode_t key;
 240
 241     // 用于区分0xfe,0xfa等指令返回码。
 242     if (scancode >= 0xFA) {
 243         return;
 244     }
 245
 246     //kprintf(KINFO "%x\n", scancode & 0xff);
 247
 248     switch (kbd_state.state)
 249     {
 250     case KBD_STATE_WAIT_KEY:
 251         if (scancode == 0xf0) { // release code
 252             kbd_state.state = KBD_STATE_RELEASED;
 253         } else if (scancode == 0xe0) {
 254             kbd_state.state = KBD_STATE_SPECIAL;
 255             kbd_state.translation_table = scancode_set2_ex;
 256         } else {
 257             key = kbd_state.translation_table[scancode];
 258             kbd_buffer_key_event(key, scancode, KBD_KEY_FPRESSED);
 259         }
 260         break;
 261     case KBD_STATE_SPECIAL:
 262         if (scancode == 0xf0) { //release code
 263             kbd_state.state = KBD_STATE_RELEASED;
 264         } else {
 265             key = kbd_state.translation_table[scancode];
 266             kbd_buffer_key_event(key, scancode, KBD_KEY_FPRESSED);
 267
 268             kbd_state.state = KBD_STATE_WAIT_KEY;
 269             kbd_state.translation_table = scancode_set2;
 270         }
 271         break;
 272     case KBD_STATE_RELEASED:
 273         key = kbd_state.translation_table[scancode];
 274         kbd_buffer_key_event(key, scancode, KBD_KEY_FRELEASED);
 275
 276         // reset the translation table to scancode_set2
 277         kbd_state.state = KBD_STATE_WAIT_KEY;
 278         kbd_state.translation_table = scancode_set2;
 279         break;
 280
 281     default:
 282         break;
 283     }
 284 }
 285
 286 static uint8_t ps2_issue_cmd(char cmd, uint16_t arg) {
 287     ps2_post_cmd(PS2_PORT_CTRL_CMDREG, cmd, arg);
 288
 289     char result;
 290
 291     // 等待PS/2控制器返回。通过轮询（polling）状态寄存器的 bit 0
 292     // 如置位，则表明返回代码此时就在 0x60 IO口上等待读取。
 293     while(!((result = io_inb(PS2_PORT_CTRL_STATUS)) & PS2_STATUS_OFULL));
 294
 295     return io_inb(PS2_PORT_ENC_CMDREG);
 296 }
 297
 298 static uint8_t ps2_issue_dev_cmd(char cmd, uint16_t arg) {
 299     ps2_post_cmd(PS2_PORT_ENC_CMDREG, cmd, arg);
 300
 301     char result;
 302
 303     // 等待PS/2控制器返回。通过轮询（polling）状态寄存器的 bit 0
 304     // 如置位，则表明返回代码此时就在 0x60 IO口上等待读取。
 305     while(!((result = io_inb(PS2_PORT_CTRL_STATUS)) & PS2_STATUS_OFULL));
 306
 307     return io_inb(PS2_PORT_ENC_CMDREG);
 308 }
 309
 310 static void ps2_post_cmd(uint8_t port, char cmd, uint16_t arg) {
 311     char result;
 312     // 等待PS/2输入缓冲区清空，这样我们才可以写入命令
 313     while((result = io_inb(PS2_PORT_CTRL_STATUS)) & PS2_STATUS_IFULL);
 314
 315     io_outb(port, cmd);
 316     if (!(arg & PS2_NO_ARG)) {
 317         // 所有参数一律通过0x60传入。
 318         io_outb(PS2_PORT_ENC_CMDREG, (uint8_t)(arg & 0x00ff));
 319     }
 320 }
 321
 322 struct kdb_keyinfo_pkt* kbd_try_read_one() {
 323     if (!key_buf.buffered_len) {
 324         return NULL;
 325     }
 326     key_buf.lock = 1;
 327     struct kdb_keyinfo_pkt* pkt_copy =
 328         (struct kdb_keyinfo_pkt*) lxmalloc(sizeof(struct kdb_keyinfo_pkt));
 329
 330     struct kdb_keyinfo_pkt* pkt_current = &key_buf.buffer[key_buf.read_ptr];
 331
 332     pkt_copy->keycode = pkt_current->keycode;
 333     pkt_copy->scancode = pkt_current->scancode;
 334     pkt_copy->state = pkt_current->state;
 335     pkt_copy->timestamp = pkt_current->timestamp;
 336     key_buf.buffered_len--;
 337     key_buf.read_ptr = (key_buf.read_ptr + 1) % PS2_KBD_RECV_BUFFER_SIZE;
 338
 339     key_buf.lock = 0;
 340     return pkt_copy;
 341 }