Kevin O'Connor | f076a3e | 2008-02-25 22:25:15 -0500 | [diff] [blame] | 1 | // 16bit code to handle keyboard requests. |
| 2 | // |
| 3 | // Copyright (C) 2008 Kevin O'Connor <kevin@koconnor.net> |
| 4 | // Copyright (C) 2002 MandrakeSoft S.A. |
| 5 | // |
Kevin O'Connor | b1b7c2a | 2009-01-15 20:52:58 -0500 | [diff] [blame] | 6 | // This file may be distributed under the terms of the GNU LGPLv3 license. |
Kevin O'Connor | f076a3e | 2008-02-25 22:25:15 -0500 | [diff] [blame] | 7 | |
Kevin O'Connor | 9521e26 | 2008-07-04 13:04:29 -0400 | [diff] [blame] | 8 | #include "biosvar.h" // GET_BDA |
Kevin O'Connor | 9521e26 | 2008-07-04 13:04:29 -0400 | [diff] [blame] | 9 | #include "bregs.h" // struct bregs |
Kevin O'Connor | 2d2fa31 | 2013-09-14 21:55:26 -0400 | [diff] [blame] | 10 | #include "config.h" // CONFIG_* |
Kevin O'Connor | 5d369d8 | 2013-09-02 20:48:46 -0400 | [diff] [blame] | 11 | #include "hw/ps2port.h" // ps2_kbd_command |
| 12 | #include "hw/usb-hid.h" // usb_kbd_command |
Kevin O'Connor | 2d2fa31 | 2013-09-14 21:55:26 -0400 | [diff] [blame] | 13 | #include "output.h" // debug_enter |
Kevin O'Connor | 1208543 | 2014-09-30 09:17:14 -0400 | [diff] [blame] | 14 | #include "stacks.h" // yield |
Kevin O'Connor | fa9c66a | 2013-09-14 19:10:40 -0400 | [diff] [blame] | 15 | #include "string.h" // memset |
Kevin O'Connor | 2d2fa31 | 2013-09-14 21:55:26 -0400 | [diff] [blame] | 16 | #include "util.h" // kbd_init |
Kevin O'Connor | f076a3e | 2008-02-25 22:25:15 -0500 | [diff] [blame] | 17 | |
Kevin O'Connor | 6704cf9 | 2010-03-13 18:51:46 -0500 | [diff] [blame] | 18 | // Bit definitions for BDA kbd_flag[012] |
| 19 | #define KF0_RSHIFT (1<<0) |
| 20 | #define KF0_LSHIFT (1<<1) |
| 21 | #define KF0_CTRLACTIVE (1<<2) |
| 22 | #define KF0_ALTACTIVE (1<<3) |
| 23 | #define KF0_SCROLLACTIVE (1<<4) |
| 24 | #define KF0_NUMACTIVE (1<<5) |
| 25 | #define KF0_CAPSACTIVE (1<<6) |
| 26 | |
| 27 | #define KF1_LCTRL (1<<0) |
| 28 | #define KF1_LALT (1<<1) |
| 29 | #define KF1_PAUSEACTIVE (1<<3) |
| 30 | #define KF1_SCROLL (1<<4) |
| 31 | #define KF1_NUM (1<<5) |
| 32 | #define KF1_CAPS (1<<6) |
| 33 | |
| 34 | #define KF2_LAST_E1 (1<<0) |
| 35 | #define KF2_LAST_E0 (1<<1) |
| 36 | #define KF2_RCTRL (1<<2) |
| 37 | #define KF2_RALT (1<<3) |
| 38 | #define KF2_101KBD (1<<4) |
| 39 | |
Kevin O'Connor | 2018eff | 2008-03-12 21:27:02 -0400 | [diff] [blame] | 40 | void |
Kevin O'Connor | d83c87b | 2013-01-21 01:14:12 -0500 | [diff] [blame] | 41 | kbd_init(void) |
Kevin O'Connor | 2018eff | 2008-03-12 21:27:02 -0400 | [diff] [blame] | 42 | { |
Kevin O'Connor | 35192dd | 2008-06-08 19:18:33 -0400 | [diff] [blame] | 43 | dprintf(3, "init keyboard\n"); |
Kevin O'Connor | 8c0e372 | 2009-01-02 14:19:43 -0500 | [diff] [blame] | 44 | u16 x = offsetof(struct bios_data_area_s, kbd_buf); |
Kevin O'Connor | 40c0e48 | 2009-09-11 02:06:02 -0400 | [diff] [blame] | 45 | SET_BDA(kbd_flag2, KF2_101KBD); |
Kevin O'Connor | 2018eff | 2008-03-12 21:27:02 -0400 | [diff] [blame] | 46 | SET_BDA(kbd_buf_head, x); |
| 47 | SET_BDA(kbd_buf_tail, x); |
| 48 | SET_BDA(kbd_buf_start_offset, x); |
| 49 | |
| 50 | SET_BDA(kbd_buf_end_offset |
| 51 | , x + FIELD_SIZEOF(struct bios_data_area_s, kbd_buf)); |
Kevin O'Connor | 2018eff | 2008-03-12 21:27:02 -0400 | [diff] [blame] | 52 | } |
| 53 | |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 54 | static u8 |
Kevin O'Connor | ea5d60a | 2016-01-10 13:01:48 -0500 | [diff] [blame] | 55 | enqueue_key(u16 keycode) |
Kevin O'Connor | f076a3e | 2008-02-25 22:25:15 -0500 | [diff] [blame] | 56 | { |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 57 | u16 buffer_start = GET_BDA(kbd_buf_start_offset); |
| 58 | u16 buffer_end = GET_BDA(kbd_buf_end_offset); |
| 59 | |
| 60 | u16 buffer_head = GET_BDA(kbd_buf_head); |
| 61 | u16 buffer_tail = GET_BDA(kbd_buf_tail); |
| 62 | |
| 63 | u16 temp_tail = buffer_tail; |
| 64 | buffer_tail += 2; |
| 65 | if (buffer_tail >= buffer_end) |
| 66 | buffer_tail = buffer_start; |
| 67 | |
| 68 | if (buffer_tail == buffer_head) |
| 69 | return 0; |
| 70 | |
Kevin O'Connor | ea5d60a | 2016-01-10 13:01:48 -0500 | [diff] [blame] | 71 | SET_FARVAR(SEG_BDA, *(u16*)(temp_tail+0), keycode); |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 72 | SET_BDA(kbd_buf_tail, buffer_tail); |
| 73 | return 1; |
| 74 | } |
| 75 | |
Kevin O'Connor | 993f9d3 | 2008-12-16 23:47:37 -0500 | [diff] [blame] | 76 | static void |
| 77 | dequeue_key(struct bregs *regs, int incr, int extended) |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 78 | { |
Kevin O'Connor | 68c5139 | 2010-03-13 22:23:44 -0500 | [diff] [blame] | 79 | yield(); |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 80 | u16 buffer_head; |
| 81 | u16 buffer_tail; |
| 82 | for (;;) { |
| 83 | buffer_head = GET_BDA(kbd_buf_head); |
| 84 | buffer_tail = GET_BDA(kbd_buf_tail); |
| 85 | |
| 86 | if (buffer_head != buffer_tail) |
| 87 | break; |
Kevin O'Connor | 993f9d3 | 2008-12-16 23:47:37 -0500 | [diff] [blame] | 88 | if (!incr) { |
| 89 | regs->flags |= F_ZF; |
| 90 | return; |
| 91 | } |
Kevin O'Connor | 94c749c | 2012-05-28 11:44:02 -0400 | [diff] [blame] | 92 | yield_toirq(); |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 93 | } |
| 94 | |
Kevin O'Connor | ea5d60a | 2016-01-10 13:01:48 -0500 | [diff] [blame] | 95 | u16 keycode = GET_FARVAR(SEG_BDA, *(u16*)(buffer_head+0)); |
| 96 | u8 ascii = keycode & 0xff; |
| 97 | if ((ascii == 0xf0 && keycode > 0xff) || (ascii == 0xe0 && !extended)) |
| 98 | keycode &= 0xff00; |
| 99 | regs->ax = keycode; |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 100 | |
Kevin O'Connor | 92f95b0 | 2008-12-29 20:42:40 -0500 | [diff] [blame] | 101 | if (!incr) { |
Kevin O'Connor | 993f9d3 | 2008-12-16 23:47:37 -0500 | [diff] [blame] | 102 | regs->flags &= ~F_ZF; |
Kevin O'Connor | 92f95b0 | 2008-12-29 20:42:40 -0500 | [diff] [blame] | 103 | return; |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 104 | } |
Kevin O'Connor | 92f95b0 | 2008-12-29 20:42:40 -0500 | [diff] [blame] | 105 | u16 buffer_start = GET_BDA(kbd_buf_start_offset); |
| 106 | u16 buffer_end = GET_BDA(kbd_buf_end_offset); |
| 107 | |
| 108 | buffer_head += 2; |
| 109 | if (buffer_head >= buffer_end) |
| 110 | buffer_head = buffer_start; |
| 111 | SET_BDA(kbd_buf_head, buffer_head); |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 112 | } |
| 113 | |
Kevin O'Connor | d488a76 | 2012-05-28 14:34:49 -0400 | [diff] [blame] | 114 | static int |
Kevin O'Connor | dd5a8a6 | 2010-05-01 19:59:34 -0400 | [diff] [blame] | 115 | kbd_command(int command, u8 *param) |
| 116 | { |
| 117 | if (usb_kbd_active()) |
Kevin O'Connor | 1208543 | 2014-09-30 09:17:14 -0400 | [diff] [blame] | 118 | return usb_kbd_command(command, param); |
| 119 | return ps2_kbd_command(command, param); |
Kevin O'Connor | dd5a8a6 | 2010-05-01 19:59:34 -0400 | [diff] [blame] | 120 | } |
| 121 | |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 122 | // read keyboard input |
| 123 | static void |
| 124 | handle_1600(struct bregs *regs) |
| 125 | { |
Kevin O'Connor | 993f9d3 | 2008-12-16 23:47:37 -0500 | [diff] [blame] | 126 | dequeue_key(regs, 1, 0); |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 127 | } |
| 128 | |
| 129 | // check keyboard status |
| 130 | static void |
| 131 | handle_1601(struct bregs *regs) |
| 132 | { |
Kevin O'Connor | 993f9d3 | 2008-12-16 23:47:37 -0500 | [diff] [blame] | 133 | dequeue_key(regs, 0, 0); |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 134 | } |
| 135 | |
| 136 | // get shift flag status |
| 137 | static void |
| 138 | handle_1602(struct bregs *regs) |
| 139 | { |
Kevin O'Connor | 68c5139 | 2010-03-13 22:23:44 -0500 | [diff] [blame] | 140 | yield(); |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 141 | regs->al = GET_BDA(kbd_flag0); |
| 142 | } |
| 143 | |
| 144 | // store key-stroke into buffer |
| 145 | static void |
| 146 | handle_1605(struct bregs *regs) |
| 147 | { |
Kevin O'Connor | ea5d60a | 2016-01-10 13:01:48 -0500 | [diff] [blame] | 148 | regs->al = !enqueue_key(regs->cx); |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 149 | } |
| 150 | |
| 151 | // GET KEYBOARD FUNCTIONALITY |
| 152 | static void |
| 153 | handle_1609(struct bregs *regs) |
| 154 | { |
| 155 | // bit Bochs Description |
| 156 | // 7 0 reserved |
| 157 | // 6 0 INT 16/AH=20h-22h supported (122-key keyboard support) |
| 158 | // 5 1 INT 16/AH=10h-12h supported (enhanced keyboard support) |
| 159 | // 4 1 INT 16/AH=0Ah supported |
| 160 | // 3 0 INT 16/AX=0306h supported |
| 161 | // 2 0 INT 16/AX=0305h supported |
| 162 | // 1 0 INT 16/AX=0304h supported |
| 163 | // 0 0 INT 16/AX=0300h supported |
| 164 | // |
| 165 | regs->al = 0x30; |
| 166 | } |
| 167 | |
| 168 | // GET KEYBOARD ID |
Kevin O'Connor | 8ab4a7d | 2012-05-28 18:31:39 -0400 | [diff] [blame] | 169 | static void noinline |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 170 | handle_160a(struct bregs *regs) |
| 171 | { |
Kevin O'Connor | 3b89719 | 2008-07-20 10:08:59 -0400 | [diff] [blame] | 172 | u8 param[2]; |
| 173 | int ret = kbd_command(ATKBD_CMD_GETID, param); |
| 174 | if (ret) { |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 175 | regs->bx = 0; |
| 176 | return; |
| 177 | } |
Kevin O'Connor | 3b89719 | 2008-07-20 10:08:59 -0400 | [diff] [blame] | 178 | regs->bx = (param[1] << 8) | param[0]; |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 179 | } |
| 180 | |
| 181 | // read MF-II keyboard input |
| 182 | static void |
| 183 | handle_1610(struct bregs *regs) |
| 184 | { |
Kevin O'Connor | 993f9d3 | 2008-12-16 23:47:37 -0500 | [diff] [blame] | 185 | dequeue_key(regs, 1, 1); |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 186 | } |
| 187 | |
| 188 | // check MF-II keyboard status |
| 189 | static void |
| 190 | handle_1611(struct bregs *regs) |
| 191 | { |
Kevin O'Connor | 993f9d3 | 2008-12-16 23:47:37 -0500 | [diff] [blame] | 192 | dequeue_key(regs, 0, 1); |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 193 | } |
| 194 | |
| 195 | // get extended keyboard status |
| 196 | static void |
| 197 | handle_1612(struct bregs *regs) |
| 198 | { |
Kevin O'Connor | 68c5139 | 2010-03-13 22:23:44 -0500 | [diff] [blame] | 199 | yield(); |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 200 | regs->al = GET_BDA(kbd_flag0); |
Kevin O'Connor | 40c0e48 | 2009-09-11 02:06:02 -0400 | [diff] [blame] | 201 | regs->ah = ((GET_BDA(kbd_flag1) & ~(KF2_RCTRL|KF2_RALT)) |
| 202 | | (GET_BDA(kbd_flag2) & (KF2_RCTRL|KF2_RALT))); |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 203 | //BX_DEBUG_INT16("int16: func 12 sending %04x\n",AX); |
| 204 | } |
| 205 | |
| 206 | static void |
| 207 | handle_166f(struct bregs *regs) |
| 208 | { |
| 209 | if (regs->al == 0x08) |
| 210 | // unsupported, aka normal keyboard |
| 211 | regs->ah = 2; |
| 212 | } |
| 213 | |
| 214 | // keyboard capability check called by DOS 5.0+ keyb |
| 215 | static void |
| 216 | handle_1692(struct bregs *regs) |
| 217 | { |
| 218 | // function int16 ah=0x10-0x12 supported |
| 219 | regs->ah = 0x80; |
| 220 | } |
| 221 | |
| 222 | // 122 keys capability check called by DOS 5.0+ keyb |
| 223 | static void |
| 224 | handle_16a2(struct bregs *regs) |
| 225 | { |
| 226 | // don't change AH : function int16 ah=0x20-0x22 NOT supported |
| 227 | } |
| 228 | |
| 229 | static void |
Kevin O'Connor | 9f4f640 | 2008-07-21 23:40:57 -0400 | [diff] [blame] | 230 | handle_16XX(struct bregs *regs) |
| 231 | { |
Kevin O'Connor | dfefeb5 | 2009-12-13 13:04:17 -0500 | [diff] [blame] | 232 | warn_unimplemented(regs); |
Kevin O'Connor | 9f4f640 | 2008-07-21 23:40:57 -0400 | [diff] [blame] | 233 | } |
| 234 | |
Kevin O'Connor | 8ab4a7d | 2012-05-28 18:31:39 -0400 | [diff] [blame] | 235 | static void noinline |
Kevin O'Connor | 1ca05b0 | 2010-01-03 17:43:37 -0500 | [diff] [blame] | 236 | set_leds(void) |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 237 | { |
Kevin O'Connor | 3b89719 | 2008-07-20 10:08:59 -0400 | [diff] [blame] | 238 | u8 shift_flags = (GET_BDA(kbd_flag0) >> 4) & 0x07; |
Kevin O'Connor | 6704cf9 | 2010-03-13 18:51:46 -0500 | [diff] [blame] | 239 | u8 kbd_led = GET_BDA(kbd_led); |
Kevin O'Connor | 3b89719 | 2008-07-20 10:08:59 -0400 | [diff] [blame] | 240 | u8 led_flags = kbd_led & 0x07; |
| 241 | if (shift_flags == led_flags) |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 242 | return; |
| 243 | |
Kevin O'Connor | 3b89719 | 2008-07-20 10:08:59 -0400 | [diff] [blame] | 244 | int ret = kbd_command(ATKBD_CMD_SETLEDS, &shift_flags); |
| 245 | if (ret) |
| 246 | // Error |
| 247 | return; |
| 248 | kbd_led = (kbd_led & ~0x07) | shift_flags; |
Kevin O'Connor | 6704cf9 | 2010-03-13 18:51:46 -0500 | [diff] [blame] | 249 | SET_BDA(kbd_led, kbd_led); |
Kevin O'Connor | f076a3e | 2008-02-25 22:25:15 -0500 | [diff] [blame] | 250 | } |
| 251 | |
| 252 | // INT 16h Keyboard Service Entry Point |
Kevin O'Connor | 1978676 | 2008-03-05 21:09:59 -0500 | [diff] [blame] | 253 | void VISIBLE16 |
Kevin O'Connor | f076a3e | 2008-02-25 22:25:15 -0500 | [diff] [blame] | 254 | handle_16(struct bregs *regs) |
| 255 | { |
Kevin O'Connor | 15c1f22 | 2008-06-12 22:59:43 -0400 | [diff] [blame] | 256 | debug_enter(regs, DEBUG_HDL_16); |
Kevin O'Connor | 4096702 | 2008-07-21 22:23:05 -0400 | [diff] [blame] | 257 | if (! CONFIG_KEYBOARD) |
| 258 | return; |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 259 | |
Kevin O'Connor | ee2efa7 | 2009-09-20 15:33:08 -0400 | [diff] [blame] | 260 | // XXX - set_leds should be called from irq handler |
Kevin O'Connor | 3b89719 | 2008-07-20 10:08:59 -0400 | [diff] [blame] | 261 | set_leds(); |
| 262 | |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 263 | switch (regs->ah) { |
| 264 | case 0x00: handle_1600(regs); break; |
| 265 | case 0x01: handle_1601(regs); break; |
| 266 | case 0x02: handle_1602(regs); break; |
| 267 | case 0x05: handle_1605(regs); break; |
| 268 | case 0x09: handle_1609(regs); break; |
| 269 | case 0x0a: handle_160a(regs); break; |
| 270 | case 0x10: handle_1610(regs); break; |
| 271 | case 0x11: handle_1611(regs); break; |
| 272 | case 0x12: handle_1612(regs); break; |
| 273 | case 0x92: handle_1692(regs); break; |
| 274 | case 0xa2: handle_16a2(regs); break; |
| 275 | case 0x6f: handle_166f(regs); break; |
Kevin O'Connor | 9f4f640 | 2008-07-21 23:40:57 -0400 | [diff] [blame] | 276 | default: handle_16XX(regs); break; |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 277 | } |
| 278 | } |
| 279 | |
| 280 | #define none 0 |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 281 | |
| 282 | static struct scaninfo { |
| 283 | u16 normal; |
| 284 | u16 shift; |
| 285 | u16 control; |
| 286 | u16 alt; |
Kevin O'Connor | ea5d60a | 2016-01-10 13:01:48 -0500 | [diff] [blame] | 287 | } scan_to_keycode[] VAR16 = { |
Kevin O'Connor | 9720484 | 2016-01-10 13:26:26 -0500 | [diff] [blame^] | 288 | { none, none, none, none }, |
| 289 | { 0x011b, 0x011b, 0x011b, 0x0100 }, /* escape */ |
| 290 | { 0x0231, 0x0221, none, 0x7800 }, /* 1! */ |
| 291 | { 0x0332, 0x0340, 0x0300, 0x7900 }, /* 2@ */ |
| 292 | { 0x0433, 0x0423, none, 0x7a00 }, /* 3# */ |
| 293 | { 0x0534, 0x0524, none, 0x7b00 }, /* 4$ */ |
| 294 | { 0x0635, 0x0625, none, 0x7c00 }, /* 5% */ |
| 295 | { 0x0736, 0x075e, 0x071e, 0x7d00 }, /* 6^ */ |
| 296 | { 0x0837, 0x0826, none, 0x7e00 }, /* 7& */ |
| 297 | { 0x0938, 0x092a, none, 0x7f00 }, /* 8* */ |
| 298 | { 0x0a39, 0x0a28, none, 0x8000 }, /* 9( */ |
| 299 | { 0x0b30, 0x0b29, none, 0x8100 }, /* 0) */ |
| 300 | { 0x0c2d, 0x0c5f, 0x0c1f, 0x8200 }, /* -_ */ |
| 301 | { 0x0d3d, 0x0d2b, none, 0x8300 }, /* =+ */ |
| 302 | { 0x0e08, 0x0e08, 0x0e7f, none }, /* backspace */ |
| 303 | { 0x0f09, 0x0f00, none, none }, /* tab */ |
| 304 | { 0x1071, 0x1051, 0x1011, 0x1000 }, /* Q */ |
| 305 | { 0x1177, 0x1157, 0x1117, 0x1100 }, /* W */ |
| 306 | { 0x1265, 0x1245, 0x1205, 0x1200 }, /* E */ |
| 307 | { 0x1372, 0x1352, 0x1312, 0x1300 }, /* R */ |
| 308 | { 0x1474, 0x1454, 0x1414, 0x1400 }, /* T */ |
| 309 | { 0x1579, 0x1559, 0x1519, 0x1500 }, /* Y */ |
| 310 | { 0x1675, 0x1655, 0x1615, 0x1600 }, /* U */ |
| 311 | { 0x1769, 0x1749, 0x1709, 0x1700 }, /* I */ |
| 312 | { 0x186f, 0x184f, 0x180f, 0x1800 }, /* O */ |
| 313 | { 0x1970, 0x1950, 0x1910, 0x1900 }, /* P */ |
| 314 | { 0x1a5b, 0x1a7b, 0x1a1b, none }, /* [{ */ |
| 315 | { 0x1b5d, 0x1b7d, 0x1b1d, none }, /* ]} */ |
| 316 | { 0x1c0d, 0x1c0d, 0x1c0a, none }, /* Enter */ |
| 317 | { none, none, none, none }, /* L Ctrl */ |
| 318 | { 0x1e61, 0x1e41, 0x1e01, 0x1e00 }, /* A */ |
| 319 | { 0x1f73, 0x1f53, 0x1f13, 0x1f00 }, /* S */ |
| 320 | { 0x2064, 0x2044, 0x2004, 0x2000 }, /* D */ |
| 321 | { 0x2166, 0x2146, 0x2106, 0x2100 }, /* F */ |
| 322 | { 0x2267, 0x2247, 0x2207, 0x2200 }, /* G */ |
| 323 | { 0x2368, 0x2348, 0x2308, 0x2300 }, /* H */ |
| 324 | { 0x246a, 0x244a, 0x240a, 0x2400 }, /* J */ |
| 325 | { 0x256b, 0x254b, 0x250b, 0x2500 }, /* K */ |
| 326 | { 0x266c, 0x264c, 0x260c, 0x2600 }, /* L */ |
| 327 | { 0x273b, 0x273a, none, none }, /* ;: */ |
| 328 | { 0x2827, 0x2822, none, none }, /* '" */ |
| 329 | { 0x2960, 0x297e, none, none }, /* `~ */ |
| 330 | { none, none, none, none }, /* L shift */ |
| 331 | { 0x2b5c, 0x2b7c, 0x2b1c, none }, /* |\ */ |
| 332 | { 0x2c7a, 0x2c5a, 0x2c1a, 0x2c00 }, /* Z */ |
| 333 | { 0x2d78, 0x2d58, 0x2d18, 0x2d00 }, /* X */ |
| 334 | { 0x2e63, 0x2e43, 0x2e03, 0x2e00 }, /* C */ |
| 335 | { 0x2f76, 0x2f56, 0x2f16, 0x2f00 }, /* V */ |
| 336 | { 0x3062, 0x3042, 0x3002, 0x3000 }, /* B */ |
| 337 | { 0x316e, 0x314e, 0x310e, 0x3100 }, /* N */ |
| 338 | { 0x326d, 0x324d, 0x320d, 0x3200 }, /* M */ |
| 339 | { 0x332c, 0x333c, none, none }, /* ,< */ |
| 340 | { 0x342e, 0x343e, none, none }, /* .> */ |
| 341 | { 0x352f, 0x353f, none, none }, /* /? */ |
| 342 | { none, none, none, none }, /* R Shift */ |
| 343 | { 0x372a, 0x372a, none, none }, /* * */ |
| 344 | { none, none, none, none }, /* L Alt */ |
| 345 | { 0x3920, 0x3920, 0x3920, 0x3920 }, /* space */ |
| 346 | { none, none, none, none }, /* caps lock */ |
| 347 | { 0x3b00, 0x5400, 0x5e00, 0x6800 }, /* F1 */ |
| 348 | { 0x3c00, 0x5500, 0x5f00, 0x6900 }, /* F2 */ |
| 349 | { 0x3d00, 0x5600, 0x6000, 0x6a00 }, /* F3 */ |
| 350 | { 0x3e00, 0x5700, 0x6100, 0x6b00 }, /* F4 */ |
| 351 | { 0x3f00, 0x5800, 0x6200, 0x6c00 }, /* F5 */ |
| 352 | { 0x4000, 0x5900, 0x6300, 0x6d00 }, /* F6 */ |
| 353 | { 0x4100, 0x5a00, 0x6400, 0x6e00 }, /* F7 */ |
| 354 | { 0x4200, 0x5b00, 0x6500, 0x6f00 }, /* F8 */ |
| 355 | { 0x4300, 0x5c00, 0x6600, 0x7000 }, /* F9 */ |
| 356 | { 0x4400, 0x5d00, 0x6700, 0x7100 }, /* F10 */ |
| 357 | { none, none, none, none }, /* Num Lock */ |
| 358 | { none, none, none, none }, /* Scroll Lock */ |
| 359 | { 0x4700, 0x4737, 0x7700, none }, /* 7 Home */ |
| 360 | { 0x4800, 0x4838, none, none }, /* 8 UP */ |
| 361 | { 0x4900, 0x4939, 0x8400, none }, /* 9 PgUp */ |
| 362 | { 0x4a2d, 0x4a2d, none, none }, /* - */ |
| 363 | { 0x4b00, 0x4b34, 0x7300, none }, /* 4 Left */ |
| 364 | { 0x4c00, 0x4c35, none, none }, /* 5 */ |
| 365 | { 0x4d00, 0x4d36, 0x7400, none }, /* 6 Right */ |
| 366 | { 0x4e2b, 0x4e2b, none, none }, /* + */ |
| 367 | { 0x4f00, 0x4f31, 0x7500, none }, /* 1 End */ |
| 368 | { 0x5000, 0x5032, none, none }, /* 2 Down */ |
| 369 | { 0x5100, 0x5133, 0x7600, none }, /* 3 PgDn */ |
| 370 | { 0x5200, 0x5230, none, none }, /* 0 Ins */ |
| 371 | { 0x5300, 0x532e, none, none }, /* Del */ |
| 372 | { none, none, none, none }, |
| 373 | { none, none, none, none }, |
| 374 | { 0x565c, 0x567c, none, none }, /* \| */ |
| 375 | { 0x8500, 0x8700, 0x8900, 0x8b00 }, /* F11 */ |
| 376 | { 0x8600, 0x8800, 0x8a00, 0x8c00 }, /* F12 */ |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 377 | }; |
| 378 | |
Kevin O'Connor | ac7eb5e | 2012-05-28 14:42:16 -0400 | [diff] [blame] | 379 | // Handle a ps2 style scancode read from the keyboard. |
| 380 | static void |
Kevin O'Connor | ee2efa7 | 2009-09-20 15:33:08 -0400 | [diff] [blame] | 381 | __process_key(u8 scancode) |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 382 | { |
Kevin O'Connor | 40c0e48 | 2009-09-11 02:06:02 -0400 | [diff] [blame] | 383 | u8 flags0 = GET_BDA(kbd_flag0); |
| 384 | u8 flags1 = GET_BDA(kbd_flag1); |
| 385 | u8 flags2 = GET_BDA(kbd_flag2); |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 386 | |
Kevin O'Connor | b532d72 | 2009-09-11 17:00:31 -0400 | [diff] [blame] | 387 | if (flags2 & KF2_LAST_E1) { |
| 388 | // Part of "pause" key (sequence is e1 1d 45 e1 9d c5) |
| 389 | if ((scancode & ~0x80) == 0x1d) |
| 390 | // Second key of sequence |
| 391 | return; |
Kevin O'Connor | ee2efa7 | 2009-09-20 15:33:08 -0400 | [diff] [blame] | 392 | // Third key of sequence - clear flag. |
Kevin O'Connor | b532d72 | 2009-09-11 17:00:31 -0400 | [diff] [blame] | 393 | flags2 &= ~KF2_LAST_E1; |
| 394 | SET_BDA(kbd_flag2, flags2); |
Kevin O'Connor | ee2efa7 | 2009-09-20 15:33:08 -0400 | [diff] [blame] | 395 | |
| 396 | if (scancode == 0xc5) { |
| 397 | // Final key in sequence. |
| 398 | |
| 399 | // XXX - do actual pause. |
| 400 | } |
Kevin O'Connor | b532d72 | 2009-09-11 17:00:31 -0400 | [diff] [blame] | 401 | return; |
| 402 | } |
| 403 | |
Kevin O'Connor | ee2efa7 | 2009-09-20 15:33:08 -0400 | [diff] [blame] | 404 | // XXX - PrtScr should cause int 0x05 |
| 405 | // XXX - Ctrl+Break should cause int 0x1B |
| 406 | // XXX - SysReq should cause int 0x15/0x85 |
| 407 | |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 408 | switch (scancode) { |
| 409 | case 0x00: |
Kevin O'Connor | ac8df8c | 2008-05-24 23:46:33 -0400 | [diff] [blame] | 410 | dprintf(1, "KBD: int09 handler: AL=0\n"); |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 411 | return; |
| 412 | |
| 413 | case 0x3a: /* Caps Lock press */ |
Kevin O'Connor | 40c0e48 | 2009-09-11 02:06:02 -0400 | [diff] [blame] | 414 | flags0 ^= KF0_CAPSACTIVE; |
| 415 | flags1 |= KF1_CAPS; |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 416 | break; |
| 417 | case 0xba: /* Caps Lock release */ |
Kevin O'Connor | 40c0e48 | 2009-09-11 02:06:02 -0400 | [diff] [blame] | 418 | flags1 &= ~KF1_CAPS; |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 419 | break; |
| 420 | |
| 421 | case 0x2a: /* L Shift press */ |
Kevin O'Connor | 40c0e48 | 2009-09-11 02:06:02 -0400 | [diff] [blame] | 422 | flags0 |= KF0_LSHIFT; |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 423 | break; |
| 424 | case 0xaa: /* L Shift release */ |
Kevin O'Connor | 40c0e48 | 2009-09-11 02:06:02 -0400 | [diff] [blame] | 425 | flags0 &= ~KF0_LSHIFT; |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 426 | break; |
| 427 | |
| 428 | case 0x36: /* R Shift press */ |
Kevin O'Connor | 40c0e48 | 2009-09-11 02:06:02 -0400 | [diff] [blame] | 429 | flags0 |= KF0_RSHIFT; |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 430 | break; |
| 431 | case 0xb6: /* R Shift release */ |
Kevin O'Connor | 40c0e48 | 2009-09-11 02:06:02 -0400 | [diff] [blame] | 432 | flags0 &= ~KF0_RSHIFT; |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 433 | break; |
| 434 | |
| 435 | case 0x1d: /* Ctrl press */ |
Kevin O'Connor | 40c0e48 | 2009-09-11 02:06:02 -0400 | [diff] [blame] | 436 | flags0 |= KF0_CTRLACTIVE; |
| 437 | if (flags2 & KF2_LAST_E0) |
| 438 | flags2 |= KF2_RCTRL; |
| 439 | else |
| 440 | flags1 |= KF1_LCTRL; |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 441 | break; |
| 442 | case 0x9d: /* Ctrl release */ |
Kevin O'Connor | 40c0e48 | 2009-09-11 02:06:02 -0400 | [diff] [blame] | 443 | flags0 &= ~KF0_CTRLACTIVE; |
| 444 | if (flags2 & KF2_LAST_E0) |
| 445 | flags2 &= ~KF2_RCTRL; |
| 446 | else |
| 447 | flags1 &= ~KF1_LCTRL; |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 448 | break; |
| 449 | |
| 450 | case 0x38: /* Alt press */ |
Kevin O'Connor | 40c0e48 | 2009-09-11 02:06:02 -0400 | [diff] [blame] | 451 | flags0 |= KF0_ALTACTIVE; |
| 452 | if (flags2 & KF2_LAST_E0) |
| 453 | flags2 |= KF2_RALT; |
| 454 | else |
| 455 | flags1 |= KF1_LALT; |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 456 | break; |
| 457 | case 0xb8: /* Alt release */ |
Kevin O'Connor | 40c0e48 | 2009-09-11 02:06:02 -0400 | [diff] [blame] | 458 | flags0 &= ~KF0_ALTACTIVE; |
| 459 | if (flags2 & KF2_LAST_E0) |
| 460 | flags2 &= ~KF2_RALT; |
| 461 | else |
| 462 | flags1 &= ~KF1_LALT; |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 463 | break; |
| 464 | |
| 465 | case 0x45: /* Num Lock press */ |
Kevin O'Connor | 40c0e48 | 2009-09-11 02:06:02 -0400 | [diff] [blame] | 466 | flags1 |= KF1_NUM; |
| 467 | flags0 ^= KF0_NUMACTIVE; |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 468 | break; |
| 469 | case 0xc5: /* Num Lock release */ |
Kevin O'Connor | 40c0e48 | 2009-09-11 02:06:02 -0400 | [diff] [blame] | 470 | flags1 &= ~KF1_NUM; |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 471 | break; |
| 472 | |
| 473 | case 0x46: /* Scroll Lock press */ |
Kevin O'Connor | 40c0e48 | 2009-09-11 02:06:02 -0400 | [diff] [blame] | 474 | flags1 |= KF1_SCROLL; |
| 475 | flags0 ^= KF0_SCROLLACTIVE; |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 476 | break; |
| 477 | case 0xc6: /* Scroll Lock release */ |
Kevin O'Connor | 40c0e48 | 2009-09-11 02:06:02 -0400 | [diff] [blame] | 478 | flags1 &= ~KF1_SCROLL; |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 479 | break; |
| 480 | |
| 481 | case 0xe0: |
| 482 | // Extended key |
Kevin O'Connor | 40c0e48 | 2009-09-11 02:06:02 -0400 | [diff] [blame] | 483 | flags2 |= KF2_LAST_E0; |
| 484 | SET_BDA(kbd_flag2, flags2); |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 485 | return; |
| 486 | case 0xe1: |
Kevin O'Connor | b532d72 | 2009-09-11 17:00:31 -0400 | [diff] [blame] | 487 | // Start of pause key sequence |
Kevin O'Connor | 40c0e48 | 2009-09-11 02:06:02 -0400 | [diff] [blame] | 488 | flags2 |= KF2_LAST_E1; |
Kevin O'Connor | b532d72 | 2009-09-11 17:00:31 -0400 | [diff] [blame] | 489 | break; |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 490 | |
| 491 | default: |
Kevin O'Connor | 3f168b6 | 2008-11-29 13:22:29 -0500 | [diff] [blame] | 492 | if (scancode & 0x80) |
| 493 | // toss key releases |
| 494 | break; |
Kevin O'Connor | 40c0e48 | 2009-09-11 02:06:02 -0400 | [diff] [blame] | 495 | if (scancode == 0x53 |
| 496 | && ((flags0 & (KF0_CTRLACTIVE|KF0_ALTACTIVE)) |
| 497 | == (KF0_CTRLACTIVE|KF0_ALTACTIVE))) { |
Kevin O'Connor | 3f168b6 | 2008-11-29 13:22:29 -0500 | [diff] [blame] | 498 | // Ctrl+alt+del - reset machine. |
Kevin O'Connor | 885e2dd | 2009-01-21 19:14:20 -0500 | [diff] [blame] | 499 | SET_BDA(soft_reset_flag, 0x1234); |
Kevin O'Connor | 43197a2 | 2014-06-06 13:49:33 -0400 | [diff] [blame] | 500 | reset(); |
Kevin O'Connor | 885e2dd | 2009-01-21 19:14:20 -0500 | [diff] [blame] | 501 | } |
Kevin O'Connor | ea5d60a | 2016-01-10 13:01:48 -0500 | [diff] [blame] | 502 | if (scancode >= ARRAY_SIZE(scan_to_keycode)) { |
Kevin O'Connor | ac8df8c | 2008-05-24 23:46:33 -0400 | [diff] [blame] | 503 | dprintf(1, "KBD: int09h_handler(): unknown scancode read: 0x%02x!\n" |
Kevin O'Connor | 438f635 | 2008-03-30 21:46:53 -0400 | [diff] [blame] | 504 | , scancode); |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 505 | return; |
| 506 | } |
Kevin O'Connor | ea5d60a | 2016-01-10 13:01:48 -0500 | [diff] [blame] | 507 | u16 keycode; |
| 508 | struct scaninfo *info = &scan_to_keycode[scancode]; |
Kevin O'Connor | 40c0e48 | 2009-09-11 02:06:02 -0400 | [diff] [blame] | 509 | if (flags0 & KF0_ALTACTIVE) { |
Kevin O'Connor | ea5d60a | 2016-01-10 13:01:48 -0500 | [diff] [blame] | 510 | keycode = GET_GLOBAL(info->alt); |
Kevin O'Connor | 40c0e48 | 2009-09-11 02:06:02 -0400 | [diff] [blame] | 511 | } else if (flags0 & KF0_CTRLACTIVE) { |
Kevin O'Connor | ea5d60a | 2016-01-10 13:01:48 -0500 | [diff] [blame] | 512 | keycode = GET_GLOBAL(info->control); |
Kevin O'Connor | 40c0e48 | 2009-09-11 02:06:02 -0400 | [diff] [blame] | 513 | } else if (flags2 & KF2_LAST_E0 |
Kevin O'Connor | 438f635 | 2008-03-30 21:46:53 -0400 | [diff] [blame] | 514 | && scancode >= 0x47 && scancode <= 0x53) { |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 515 | /* extended keys handling */ |
Kevin O'Connor | ea5d60a | 2016-01-10 13:01:48 -0500 | [diff] [blame] | 516 | keycode = (scancode << 8) | 0xe0; |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 517 | } else { |
Kevin O'Connor | 9720484 | 2016-01-10 13:26:26 -0500 | [diff] [blame^] | 518 | u8 useshift = flags0 & (KF0_RSHIFT|KF0_LSHIFT) ? 1 : 0; |
| 519 | u8 ascii = GET_GLOBAL(info->normal) & 0xff; |
| 520 | if ((flags0 & KF0_NUMACTIVE && scancode >= 0x47 && scancode <= 0x53) |
| 521 | || (flags0 & KF0_CAPSACTIVE && ascii >= 'a' && ascii <= 'z')) |
| 522 | // Numlock/capslock toggles shift on certain keys |
| 523 | useshift ^= 1; |
| 524 | if (useshift) |
Kevin O'Connor | ea5d60a | 2016-01-10 13:01:48 -0500 | [diff] [blame] | 525 | keycode = GET_GLOBAL(info->shift); |
| 526 | else |
| 527 | keycode = GET_GLOBAL(info->normal); |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 528 | } |
Kevin O'Connor | ea5d60a | 2016-01-10 13:01:48 -0500 | [diff] [blame] | 529 | if (!keycode) |
| 530 | dprintf(1, "KBD: keycode is zero?\n"); |
| 531 | enqueue_key(keycode); |
Kevin O'Connor | 4b60c00 | 2008-02-25 22:29:55 -0500 | [diff] [blame] | 532 | break; |
| 533 | } |
Kevin O'Connor | 40c0e48 | 2009-09-11 02:06:02 -0400 | [diff] [blame] | 534 | flags2 &= ~KF2_LAST_E0; |
| 535 | |
| 536 | SET_BDA(kbd_flag0, flags0); |
| 537 | SET_BDA(kbd_flag1, flags1); |
| 538 | SET_BDA(kbd_flag2, flags2); |
Kevin O'Connor | f076a3e | 2008-02-25 22:25:15 -0500 | [diff] [blame] | 539 | } |
| 540 | |
Kevin O'Connor | 114592f | 2009-09-28 21:32:08 -0400 | [diff] [blame] | 541 | void |
Kevin O'Connor | ee2efa7 | 2009-09-20 15:33:08 -0400 | [diff] [blame] | 542 | process_key(u8 key) |
| 543 | { |
Kevin O'Connor | 5787748 | 2009-12-09 21:00:41 -0500 | [diff] [blame] | 544 | if (!CONFIG_KEYBOARD) |
| 545 | return; |
| 546 | |
Kevin O'Connor | ee2efa7 | 2009-09-20 15:33:08 -0400 | [diff] [blame] | 547 | if (CONFIG_KBD_CALL_INT15_4F) { |
| 548 | // allow for keyboard intercept |
Kevin O'Connor | ecdc655 | 2012-05-28 14:25:15 -0400 | [diff] [blame] | 549 | struct bregs br; |
| 550 | memset(&br, 0, sizeof(br)); |
| 551 | br.eax = (0x4f << 8) | key; |
| 552 | br.flags = F_IF|F_CF; |
| 553 | call16_int(0x15, &br); |
| 554 | if (!(br.flags & F_CF)) |
Kevin O'Connor | ee2efa7 | 2009-09-20 15:33:08 -0400 | [diff] [blame] | 555 | return; |
Kevin O'Connor | ecdc655 | 2012-05-28 14:25:15 -0400 | [diff] [blame] | 556 | key = br.eax; |
Kevin O'Connor | ee2efa7 | 2009-09-20 15:33:08 -0400 | [diff] [blame] | 557 | } |
| 558 | __process_key(key); |
| 559 | } |