converter/ibmpc_usb/ibmpc_usb.c

   1 /*
   2 Copyright 2019,2020 Jun Wako <wakojun@gmail.com>
   3
   4 This program is free software: you can redistribute it and/or modify
   5 it under the terms of the GNU General Public License as published by
   6 the Free Software Foundation, either version 2 of the License, or
   7 (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16 */
  17
  18 #include <stdint.h>
  19 #include <stdbool.h>
  20 #include "print.h"
  21 #include "util.h"
  22 #include "debug.h"
  23 #include "ibmpc.h"
  24 #include "host.h"
  25 #include "led.h"
  26 #include "matrix.h"
  27 #include "timer.h"
  28 #include "action.h"
  29 #include "ibmpc_usb.h"
  30 #include "ibmpc.h"
  31
  32
  33 static void matrix_make(uint8_t code);
  34 static void matrix_break(uint8_t code);
  35
  36 static int8_t process_cs1(void);
  37 static int8_t process_cs2(void);
  38 static int8_t process_cs3(void);
  39
  40
  41 static uint8_t matrix[MATRIX_ROWS];
  42 #define ROW(code)      ((code>>3)&0x0F)
  43 #define COL(code)      (code&0x07)
  44
  45 static int16_t read_wait(uint16_t wait_ms)
  46 {
  47     uint16_t start = timer_read();
  48     int16_t code;
  49     while ((code = ibmpc_host_recv()) == -1 && timer_elapsed(start) < wait_ms);
  50     return code;
  51 }
  52
  53 static uint16_t read_keyboard_id(void)
  54 {
  55     uint16_t id = 0;
  56     int16_t  code = 0;
  57
  58     // Disable
  59     //code = ibmpc_host_send(0xF5);
  60
  61     // Read ID
  62     code = ibmpc_host_send(0xF2);
  63     if (code == -1) { id = 0xFFFF; goto DONE; }     // XT or No keyboard
  64     if (code != 0xFA) { id = 0xFFFE; goto DONE; }   // Broken PS/2?
  65
  66     // ID takes 500ms max TechRef [8] 4-41
  67     code = read_wait(500);
  68     if (code == -1) { id = 0x0000; goto DONE; }     // AT
  69     id = (code & 0xFF)<<8;
  70
  71     // Mouse responds with one-byte 00, this returns 00FF [y] p.14
  72     code = read_wait(500);
  73     id |= code & 0xFF;
  74
  75 DONE:
  76     // Enable
  77     //code = ibmpc_host_send(0xF4);
  78
  79     return id;
  80 }
  81
  82 void hook_early_init(void)
  83 {
  84     ibmpc_host_init();
  85     ibmpc_host_enable();
  86 }
  87
  88 void matrix_init(void)
  89 {
  90     debug_enable = true;
  91
  92     // initialize matrix state: all keys off
  93     for (uint8_t i=0; i < MATRIX_ROWS; i++) matrix[i] = 0x00;
  94
  95     return;
  96 }
  97
  98 /*
  99  * keyboard recognition
 100  *
 101  * 1. Send F2 to get keyboard ID
 102  *      a. no ACK(FA): XT keyobard
 103  *      b. ACK but no ID: 84-key AT keyboard CodeSet2
 104  *      c. ID is AB 83: PS/2 keyboard CodeSet2
 105  *      d. ID is BF BF: Terminal keyboard CodeSet3
 106  *      e. error on recv: maybe broken PS/2
 107  */
 108 uint8_t current_protocol = 0;
 109 uint16_t keyboard_id = 0x0000;
 110 keyboard_kind_t keyboard_kind = NONE;
 111 uint8_t matrix_scan(void)
 112 {
 113     // scan code reading states
 114     static enum {
 115         INIT,
 116         XT_RESET,
 117         XT_RESET_WAIT,
 118         XT_RESET_DONE,
 119         WAIT_AA,
 120         WAIT_AABF,
 121         WAIT_AABFBF,
 122         READ_ID,
 123         SETUP,
 124         LOOP,
 125     } state = INIT;
 126     static uint16_t init_time;
 127
 128
 129     if (ibmpc_error) {
 130         xprintf("\nERR:%02X\n", ibmpc_error);
 131
 132         // when recv error, neither send error nor buffer full
 133         if (!(ibmpc_error & (IBMPC_ERR_SEND | IBMPC_ERR_FULL))) {
 134             // keyboard init again
 135             if (state == LOOP) {
 136                 xprintf("init\n");
 137                 state = INIT;
 138             }
 139         }
 140
 141         // clear or process error
 142         ibmpc_error = IBMPC_ERR_NONE;
 143     }
 144
 145     // check ISR state debug
 146     if (ibmpc_isr_debug) {
 147         xprintf("\nISR:%04X\n", ibmpc_isr_debug);
 148         ibmpc_isr_debug = 0;
 149     }
 150
 151     // check protocol AT/XT
 152     if (ibmpc_protocol != current_protocol) {
 153         xprintf("\nPROTO:%02X\n", ibmpc_protocol);
 154         current_protocol = ibmpc_protocol;
 155     }
 156
 157     switch (state) {
 158         case INIT:
 159             xprintf("I%u ", timer_read());
 160             keyboard_kind = NONE;
 161             keyboard_id = 0x0000;
 162
 163             matrix_clear();
 164             clear_keyboard();
 165
 166             state = XT_RESET;
 167             break;
 168         case XT_RESET:
 169             // Reset XT-initialize keyboard
 170             // XT: hard reset 500ms for IBM XT Type-1 keyboard and clones
 171             // XT: soft reset 20ms min(clock Lo)
 172             ibmpc_host_disable();   // soft reset: inihibit(clock Lo/Data Hi)
 173             IBMPC_RST_LO();         // hard reset: reset pin Lo
 174
 175             init_time = timer_read();
 176             state = XT_RESET_WAIT;
 177             break;
 178         case XT_RESET_WAIT:
 179             if (timer_elapsed(init_time) > 500) {
 180                 state = XT_RESET_DONE;
 181             }
 182             break;
 183         case XT_RESET_DONE:
 184             IBMPC_RST_HIZ();        // hard reset: reset pin HiZ
 185             ibmpc_host_isr_clear();
 186             ibmpc_host_enable();    // soft reset: idle(clock Hi/Data Hi)
 187
 188             xprintf("X%u ", timer_read());
 189             init_time = timer_read();
 190             state = WAIT_AA;
 191             break;
 192         case WAIT_AA:
 193             // 1) Read BAT code and ID on keybaord power-up
 194             // For example, XT/AT sends 'AA' and Terminal sends 'AA BF BF' after BAT
 195             // AT 84-key: POR and BAT can take 900-9900ms according to AT TechRef [8] 4-7
 196             // AT 101/102-key: POR and BAT can take 450-2500ms according to AT TechRef [8] 4-39
 197             // 2) Read key typed by user or anything after error on protocol or scan code
 198             // This can happen in case of keyboard hotswap, unstable hardware, signal integrity problem or bug
 199
 200             /* wait until keyboard sends any code without 10000ms timeout
 201             if (timer_elapsed(init_time) > 10000) {
 202                 state = READ_ID;
 203             }
 204             */
 205             if (ibmpc_host_recv() != -1) {  // wait for AA
 206                 xprintf("W%u ", timer_read());
 207                 init_time = timer_read();
 208                 state = WAIT_AABF;
 209             }
 210             break;
 211         case WAIT_AABF:
 212             // NOTE: we can omit to wait BF BF
 213             // ID takes 500ms max? TechRef [8] 4-41, though 1ms is enough for 122-key Terminal 6110345
 214             if (timer_elapsed(init_time) > 500) {
 215                 state = READ_ID;
 216             }
 217             if (ibmpc_host_recv() != -1) {  // wait for BF
 218                 xprintf("W%u ", timer_read());
 219                 init_time = timer_read();
 220                 state = WAIT_AABFBF;
 221             }
 222             break;
 223         case WAIT_AABFBF:
 224             if (timer_elapsed(init_time) > 500) {
 225                 state = READ_ID;
 226             }
 227             if (ibmpc_host_recv() != -1) {  // wait for BF
 228                 xprintf("W%u ", timer_read());
 229                 state = READ_ID;
 230             }
 231             break;
 232         case READ_ID:
 233             xprintf("R%u ", timer_read());
 234
 235             // SKIDATA-2-DE(and some other keyboards?) stores 'Code Set' setting in nonvlatile memory
 236             // and keeps it until receiving reset. Sending reset here may be useful to clear it, perhaps.
 237             // https://github.com/tmk/tmk_keyboard/wiki/IBM-PC-AT-Keyboard-Protocol#select-alternate-scan-codesf0
 238             //ibmpc_host_send(0xFF);  // reset command
 239             //read_wait(500);         // BAT takes 600-900ms(84-key) or 300-500ms(101/102-key) [8] 4-7, 4-39
 240
 241             keyboard_id = read_keyboard_id();
 242             if (ibmpc_error) {
 243                 xprintf("\nERR:%02X\n", ibmpc_error);
 244                 ibmpc_error = IBMPC_ERR_NONE;
 245             }
 246
 247             if (0x0000 == keyboard_id) {            // CodeSet2 AT(IBM PC AT 84-key)
 248                 keyboard_kind = PC_AT;
 249             } else if (0xFFFF == keyboard_id) {     // CodeSet1 XT
 250                 keyboard_kind = PC_XT;
 251             } else if (0xFFFE == keyboard_id) {     // CodeSet2 PS/2 fails to response?
 252                 keyboard_kind = PC_AT;
 253             } else if (0x00FF == keyboard_id) {     // Mouse is not supported
 254                 xprintf("Mouse: not supported\n");
 255                 keyboard_kind = NONE;
 256 #ifdef G80_2551_SUPPORT
 257             } else if (0xAB86 == keyboard_id ||
 258                        0xAB85 == keyboard_id) {     // For G80-2551 and other 122-key terminal
 259                 // https://github.com/tmk/tmk_keyboard/wiki/IBM-PC-AT-Keyboard-Protocol#ab86
 260                 // https://github.com/tmk/tmk_keyboard/wiki/IBM-PC-AT-Keyboard-Protocol#ab85
 261
 262                 if ((0xFA == ibmpc_host_send(0xF0)) &&
 263                     (0xFA == ibmpc_host_send(0x03))) {
 264                     // switch to code set 3
 265                     keyboard_kind = PC_TERMINAL;
 266                 } else {
 267                     keyboard_kind = PC_AT;
 268                 }
 269 #endif
 270             } else if (0xBFB0 == keyboard_id) {     // IBM RT Keyboard
 271                 // https://github.com/tmk/tmk_keyboard/wiki/IBM-PC-AT-Keyboard-Protocol#bfb0
 272                 // TODO: LED indicator fix
 273                 //keyboard_kind = PC_TERMINAL_IBM_RT;
 274                 keyboard_kind = PC_TERMINAL;
 275             } else if (0xAB00 == (keyboard_id & 0xFF00)) {  // CodeSet2 PS/2
 276                 keyboard_kind = PC_AT;
 277             } else if (0xBF00 == (keyboard_id & 0xFF00)) {  // CodeSet3 Terminal
 278                 keyboard_kind = PC_TERMINAL;
 279             } else {
 280                 keyboard_kind = PC_AT;
 281             }
 282
 283             xprintf("ID:%04X(%d)\n", keyboard_id, keyboard_kind);
 284
 285             state = SETUP;
 286             break;
 287         case SETUP:
 288             xprintf("S%u ", timer_read());
 289             switch (keyboard_kind) {
 290                 case PC_XT:
 291                     break;
 292                 case PC_AT:
 293                     led_set(host_keyboard_leds());
 294                     break;
 295                 case PC_TERMINAL:
 296                     // Set all keys to make/break type
 297                     ibmpc_host_send(0xF8);
 298                     break;
 299                 default:
 300                     break;
 301             }
 302             state = LOOP;
 303             xprintf("L%u ", timer_read());
 304         case LOOP:
 305             switch (keyboard_kind) {
 306                 case PC_XT:
 307                     if (process_cs1() == -1) state = INIT;
 308                     break;
 309                 case PC_AT:
 310                     if (process_cs2() == -1) state = INIT;
 311                     break;
 312                 case PC_TERMINAL:
 313                     if (process_cs3() == -1) state = INIT;
 314                     break;
 315                 default:
 316                     break;
 317             }
 318             break;
 319         default:
 320             break;
 321     }
 322     return 1;
 323 }
 324
 325 inline
 326 bool matrix_is_on(uint8_t row, uint8_t col)
 327 {
 328     return (matrix[row] & (1<<col));
 329 }
 330
 331 inline
 332 uint8_t matrix_get_row(uint8_t row)
 333 {
 334     return matrix[row];
 335 }
 336
 337 uint8_t matrix_key_count(void)
 338 {
 339     uint8_t count = 0;
 340     for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
 341         count += bitpop(matrix[i]);
 342     }
 343     return count;
 344 }
 345
 346
 347 inline
 348 static void matrix_make(uint8_t code)
 349 {
 350     if (!matrix_is_on(ROW(code), COL(code))) {
 351         matrix[ROW(code)] |= 1<<COL(code);
 352     }
 353 }
 354
 355 inline
 356 static void matrix_break(uint8_t code)
 357 {
 358     if (matrix_is_on(ROW(code), COL(code))) {
 359         matrix[ROW(code)] &= ~(1<<COL(code));
 360     }
 361 }
 362
 363 void matrix_clear(void)
 364 {
 365     for (uint8_t i=0; i < MATRIX_ROWS; i++) matrix[i] = 0x00;
 366 }
 367
 368 void led_set(uint8_t usb_led)
 369 {
 370     if (keyboard_kind == NONE) return;
 371     //if (keyboard_kind != PC_AT) return;
 372
 373     uint8_t ibmpc_led = 0;
 374     if (usb_led &  (1<<USB_LED_SCROLL_LOCK))
 375         ibmpc_led |= (1<<IBMPC_LED_SCROLL_LOCK);
 376     if (usb_led &  (1<<USB_LED_NUM_LOCK))
 377         ibmpc_led |= (1<<IBMPC_LED_NUM_LOCK);
 378     if (usb_led &  (1<<USB_LED_CAPS_LOCK))
 379         ibmpc_led |= (1<<IBMPC_LED_CAPS_LOCK);
 380     ibmpc_host_set_led(ibmpc_led);
 381 }
 382
 383
 384 /*******************************************************************************
 385  * XT: Scan Code Set 1
 386  *
 387  * See [3], [a]
 388  *
 389  * E0-escaped scan codes are translated into unused range of the matrix.(54-7F)
 390  *
 391  *     01-53: Normal codes used in original XT keyboard
 392  *     54-7F: Not used in original XT keyboard
 393  *
 394  *         0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
 395  *     50  -   -   -   -   *   *   x   x   x   x   *   *   *   *   *   *
 396  *     60  *   *   *   *   x   x   x   x   x   x   x   x   x   x   x   *
 397  *     70  x   *   *   x   *   *   x   *   *   x   *   x   *   x   x   *
 398  *
 399  * -: codes existed in original XT keyboard
 400  * *: E0-escaped codes translated
 401  * x: Non-espcaped codes(Some are not used in real keyboards probably)
 402  *
 403  * Codes assigned in range 54-7F:
 404  *
 405  *     50  -                60  Up*                 70  KANAx
 406  *     51  -                61  Left*               71  Insert*
 407  *     52  -                62  Down*               72  Delete*
 408  *     53  -                63  Right*              73  ROx
 409  *     54  PrintScr*        64  F13x                74  Home*
 410  *     55  Pause*           65  F14x                75  End*
 411  *     56  Euro2x           66  F15x                76  F24x
 412  *     57  F11x             67  F16x                77  PageUp*
 413  *     58  F12x             68  F17x                78  PageDown*
 414  *     59  Keypad=x         69  F18x                79  HENKANx
 415  *     5A  LGUI*            6A  F19x                7A  RCTL*
 416  *     5B  RGUI*            6B  F20x                7B  MUHENKANx
 417  *     5C  APP*             6C  F21x                7C  RALT*
 418  *     5D  Mute*            6D  F22x                7D  JPYx
 419  *     5E  Volume Down*     6E  F23x                7E  Keypad,x
 420  *     5F  Volume Up*       6F  Keypad Enter*       7F  Keypad/ *
 421  */
 422 static uint8_t cs1_e0code(uint8_t code) {
 423     switch(code) {
 424         // Original IBM XT keyboard doesn't use E0-codes probably
 425         // Some XT compatilble keyobards need these keys?
 426         case 0x37: return 0x54; // Print Screen
 427         case 0x46: return 0x55; // Ctrl + Pause
 428         case 0x5B: return 0x5A; // Left  GUI
 429         case 0x5C: return 0x5B; // Right GUI
 430         case 0x5D: return 0x5C; // Application
 431         case 0x20: return 0x5D; // Mute
 432         case 0x2E: return 0x5E; // Volume Down
 433         case 0x30: return 0x5F; // Volume Up
 434         case 0x48: return 0x60; // Up
 435         case 0x4B: return 0x61; // Left
 436         case 0x50: return 0x62; // Down
 437         case 0x4D: return 0x63; // Right
 438         case 0x1C: return 0x6F; // Keypad Enter
 439         case 0x52: return 0x71; // Insert
 440         case 0x53: return 0x72; // Delete
 441         case 0x47: return 0x74; // Home
 442         case 0x4F: return 0x75; // End
 443         case 0x49: return 0x77; // Page Up
 444         case 0x51: return 0x78; // Page Down
 445         case 0x1D: return 0x7A; // Right Ctrl
 446         case 0x38: return 0x7C; // Right Alt
 447         case 0x35: return 0x7F; // Keypad /
 448
 449         // Shared matrix cell with other keys
 450         case 0x5E: return 0x70; // Power (KANA)
 451         case 0x5F: return 0x79; // Sleep (HENKAN)
 452         case 0x63: return 0x7B; // Wake  (MUHENKAN)
 453
 454         default:
 455            xprintf("!CS1_E0_%02X!\n", code);
 456            return code;
 457     }
 458     return 0x00;
 459 }
 460
 461 static int8_t process_cs1(void)
 462 {
 463     static enum {
 464         INIT,
 465         E0,
 466         // Pause: E1 1D 45, E1 9D C5 [a] (TODO: test)
 467         E1,
 468         E1_1D,
 469         E1_9D,
 470     } state = INIT;
 471
 472     uint16_t code = ibmpc_host_recv();
 473     if (code == -1) {
 474         return 0;
 475     }
 476
 477     // Check invalid codes; 0x59-7F won't be used in real XT keyboards probably
 478     // 0x62 is used to handle escape code E0 and E1
 479     if ((code & 0x7F) >= 0x62) {
 480         xprintf("!CS1_INV!\n");
 481         state = INIT;
 482         return -1;
 483     }
 484
 485     switch (state) {
 486         case INIT:
 487             switch (code) {
 488                 case 0x00:
 489                 case 0xFF:  // Error/Overrun [3]p.26
 490                     xprintf("!CS1_ERR!\n");
 491                     return -1;
 492                     break;
 493                 case 0xE0:
 494                     state = E0;
 495                     break;
 496                 case 0xE1:
 497                     state = E1;
 498                     break;
 499                 default:
 500                     if (code < 0x80)
 501                         matrix_make(code);
 502                     else
 503                         matrix_break(code & 0x7F);
 504                     break;
 505             }
 506             break;
 507         case E0:
 508             switch (code) {
 509                 case 0x2A:
 510                 case 0xAA:
 511                 case 0x36:
 512                 case 0xB6:
 513                     //ignore fake shift
 514                     state = INIT;
 515                     break;
 516                 default:
 517                     if (code < 0x80)
 518                         matrix_make(cs1_e0code(code));
 519                     else
 520                         matrix_break(cs1_e0code(code & 0x7F));
 521                     state = INIT;
 522                     break;
 523             }
 524             break;
 525         case E1:
 526             switch (code) {
 527                 case 0x1D:
 528                     state = E1_1D;
 529                     break;
 530                 case 0x9D:
 531                     state = E1_9D;
 532                     break;
 533                 default:
 534                     state = INIT;
 535                     break;
 536             }
 537             break;
 538         case E1_1D:
 539             switch (code) {
 540                 case 0x45:
 541                     matrix_make(0x55);
 542                     break;
 543                 default:
 544                     state = INIT;
 545                     break;
 546             }
 547             break;
 548         case E1_9D:
 549             switch (code) {
 550                 case 0x45:
 551                     matrix_break(0x55);
 552                     break;
 553                 default:
 554                     state = INIT;
 555                     break;
 556             }
 557             break;
 558         default:
 559             state = INIT;
 560     }
 561     return 0;
 562 }
 563
 564
 565 /*******************************************************************************
 566  * AT, PS/2: Scan Code Set 2
 567  *
 568  * Exceptional Handling
 569  * --------------------
 570  * Some keys should be handled exceptionally. See [b].
 571  *
 572  * Scan codes are varied or prefix/postfix'd depending on modifier key state.
 573  *
 574  * 1) Insert, Delete, Home, End, PageUp, PageDown, Up, Down, Right, Left
 575  *     a) when Num Lock is off
 576  *     modifiers | make                      | break
 577  *     ----------+---------------------------+----------------------
 578  *     Ohter     |                    <make> | <break>
 579  *     LShift    | E0 F0 12           <make> | <break>  E0 12
 580  *     RShift    | E0 F0 59           <make> | <break>  E0 59
 581  *     L+RShift  | E0 F0 12  E0 F0 59 <make> | <break>  E0 59 E0 12
 582  *
 583  *     b) when Num Lock is on
 584  *     modifiers | make                      | break
 585  *     ----------+---------------------------+----------------------
 586  *     Other     | E0 12              <make> | <break>  E0 F0 12
 587  *     Shift'd   |                    <make> | <break>
 588  *
 589  *     Handling: These prefix/postfix codes are ignored.
 590  *
 591  *
 592  * 2) Keypad /
 593  *     modifiers | make                      | break
 594  *     ----------+---------------------------+----------------------
 595  *     Ohter     |                    <make> | <break>
 596  *     LShift    | E0 F0 12           <make> | <break>  E0 12
 597  *     RShift    | E0 F0 59           <make> | <break>  E0 59
 598  *     L+RShift  | E0 F0 12  E0 F0 59 <make> | <break>  E0 59 E0 12
 599  *
 600  *     Handling: These prefix/postfix codes are ignored.
 601  *
 602  *
 603  * 3) PrintScreen
 604  *     modifiers | make         | break
 605  *     ----------+--------------+-----------------------------------
 606  *     Other     | E0 12  E0 7C | E0 F0 7C  E0 F0 12
 607  *     Shift'd   |        E0 7C | E0 F0 7C
 608  *     Control'd |        E0 7C | E0 F0 7C
 609  *     Alt'd     |           84 | F0 84
 610  *
 611  *     Handling: These prefix/postfix codes are ignored, and both scan codes
 612  *               'E0 7C' and 84 are seen as PrintScreen.
 613  *
 614  * 4) Pause
 615  *     modifiers | make(no break code)
 616  *     ----------+--------------------------------------------------
 617  *     Other     | E1 14 77 E1 F0 14 F0 77
 618  *     Control'd | E0 7E E0 F0 7E
 619  *
 620  *     Handling: Both code sequences are treated as a whole.
 621  *               And we need a ad hoc 'pseudo break code' hack to get the key off
 622  *               because it has no break code.
 623  *
 624  * Notes:
 625  * 'Hanguel/English'(F1) and 'Hanja'(F2) have no break code. See [a].
 626  * These two Korean keys need exceptional handling and are not supported for now.
 627  *
 628  */
 629 static uint8_t cs2_e0code(uint8_t code) {
 630     switch(code) {
 631         // E0 prefixed codes translation See [a].
 632         case 0x11: return 0x0F; // right alt
 633         case 0x14: return 0x17; // right control
 634         case 0x1F: return 0x19; // left GUI
 635         case 0x27: return 0x1F; // right GUI
 636         case 0x2F: return 0x5C; // apps
 637         case 0x4A: return 0x60; // keypad /
 638         case 0x5A: return 0x62; // keypad enter
 639         case 0x69: return 0x27; // end
 640         case 0x6B: return 0x53; // cursor left
 641         case 0x6C: return 0x2F; // home
 642         case 0x70: return 0x39; // insert
 643         case 0x71: return 0x37; // delete
 644         case 0x72: return 0x3F; // cursor down
 645         case 0x74: return 0x47; // cursor right
 646         case 0x75: return 0x4F; // cursor up
 647         case 0x7A: return 0x56; // page down
 648         case 0x7D: return 0x5E; // page up
 649         case 0x7C: return 0x7F; // Print Screen
 650         case 0x7E: return 0x00; // Control'd Pause
 651
 652         case 0x21: return 0x65; // volume down
 653         case 0x32: return 0x6E; // volume up
 654         case 0x23: return 0x6F; // mute
 655         case 0x10: return 0x08; // (WWW search)     -> F13
 656         case 0x18: return 0x10; // (WWW favourites) -> F14
 657         case 0x20: return 0x18; // (WWW refresh)    -> F15
 658         case 0x28: return 0x20; // (WWW stop)       -> F16
 659         case 0x30: return 0x28; // (WWW forward)    -> F17
 660         case 0x38: return 0x30; // (WWW back)       -> F18
 661         case 0x3A: return 0x38; // (WWW home)       -> F19
 662         case 0x40: return 0x40; // (my computer)    -> F20
 663         case 0x48: return 0x48; // (email)          -> F21
 664         case 0x2B: return 0x50; // (calculator)     -> F22
 665         case 0x34: return 0x08; // (play/pause)     -> F13
 666         case 0x3B: return 0x10; // (stop)           -> F14
 667         case 0x15: return 0x18; // (previous track) -> F15
 668         case 0x4D: return 0x20; // (next track)     -> F16
 669         case 0x50: return 0x28; // (media select)   -> F17
 670         case 0x5E: return 0x50; // (ACPI wake)      -> F22
 671         case 0x3F: return 0x57; // (ACPI sleep)     -> F23
 672         case 0x37: return 0x5F; // (ACPI power)     -> F24
 673
 674         // https://github.com/tmk/tmk_keyboard/pull/636
 675         case 0x03: return 0x18; // Help        DEC LK411 -> F15
 676         case 0x04: return 0x08; // F13         DEC LK411
 677         case 0x0B: return 0x20; // Do          DEC LK411 -> F16
 678         case 0x0C: return 0x10; // F14         DEC LK411
 679         case 0x0D: return 0x19; // LCompose    DEC LK411 -> LGUI
 680         case 0x79: return 0x6D; // KP-         DEC LK411 -> PCMM
 681         case 0x83: return 0x28; // F17         DEC LK411
 682         default: return (code & 0x7F);
 683     }
 684 }
 685
 686 static int8_t process_cs2(void)
 687 {
 688     // scan code reading states
 689     static enum {
 690         INIT,
 691         F0,
 692         E0,
 693         E0_F0,
 694         // Pause
 695         E1,
 696         E1_14,
 697         E1_F0,
 698         E1_F0_14,
 699         E1_F0_14_F0,
 700     } state = INIT;
 701
 702     uint16_t code = ibmpc_host_recv();
 703     if (code == -1) {
 704         return 0;
 705     }
 706
 707     switch (state) {
 708         case INIT:
 709             switch (code) {
 710                 case 0x00:  // Error/Overrun [3]p.26
 711                     xprintf("!CS2_OVR!\n");
 712                     matrix_clear();
 713                     clear_keyboard();
 714                     break;
 715                 case 0xFF:
 716                     matrix_clear();
 717                     xprintf("!CS2_ERR!\n");
 718                     state = INIT;
 719                     return -1;
 720                     break;
 721                 case 0xE0:
 722                     state = E0;
 723                     break;
 724                 case 0xF0:
 725                     state = F0;
 726                     break;
 727                 case 0xE1:
 728                     state = E1;
 729                     break;
 730                 case 0x83:  // F7
 731                     matrix_make(0x02);
 732                     state = INIT;
 733                     break;
 734                 case 0x84:  // Alt'd PrintScreen
 735                     matrix_make(0x7F);
 736                     state = INIT;
 737                     break;
 738                 case 0xAA:  // Self-test passed
 739                 case 0xFC:  // Self-test failed
 740                     // reset or plugin-in new keyboard
 741                     state = INIT;
 742                     return -1;
 743                     break;
 744                 default:    // normal key make
 745                     state = INIT;
 746                     if (code < 0x80) {
 747                         matrix_make(code);
 748                     } else {
 749                         matrix_clear();
 750                         xprintf("!CS2_INIT!\n");
 751                         return -1;
 752                     }
 753             }
 754             break;
 755         case E0:    // E0-Prefixed
 756             switch (code) {
 757                 case 0x12:  // to be ignored
 758                 case 0x59:  // to be ignored
 759                     state = INIT;
 760                     break;
 761                 case 0xF0:
 762                     state = E0_F0;
 763                     break;
 764                 default:
 765                     state = INIT;
 766                     if (code < 0x80) {
 767                         matrix_make(cs2_e0code(code));
 768                     } else {
 769                         matrix_clear();
 770                         xprintf("!CS2_E0!\n");
 771                         return -1;
 772                     }
 773             }
 774             break;
 775         case F0:    // Break code
 776             switch (code) {
 777                 case 0x83:  // F7
 778                     matrix_break(0x02);
 779                     state = INIT;
 780                     break;
 781                 case 0x84:  // Alt'd PrintScreen
 782                     matrix_break(0x7F);
 783                     state = INIT;
 784                     break;
 785                 default:
 786                     state = INIT;
 787                     if (code < 0x80) {
 788                         matrix_break(code);
 789                     } else {
 790                         matrix_clear();
 791                         xprintf("!CS2_F0!\n");
 792                         return -1;
 793                     }
 794             }
 795             break;
 796         case E0_F0: // Break code of E0-prefixed
 797             switch (code) {
 798                 case 0x12:  // to be ignored
 799                 case 0x59:  // to be ignored
 800                     state = INIT;
 801                     break;
 802                 default:
 803                     state = INIT;
 804                     if (code < 0x80) {
 805                         matrix_break(cs2_e0code(code));
 806                     } else {
 807                         matrix_clear();
 808                         xprintf("!CS2_E0_F0!\n");
 809                         return -1;
 810                     }
 811             }
 812             break;
 813         // Pause make: E1 14 77
 814         case E1:
 815             switch (code) {
 816                 case 0x14:
 817                     state = E1_14;
 818                     break;
 819                 case 0xF0:
 820                     state = E1_F0;
 821                     break;
 822                 default:
 823                     state = INIT;
 824             }
 825             break;
 826         case E1_14:
 827             switch (code) {
 828                 case 0x77:
 829                     matrix_make(0x00);
 830                     state = INIT;
 831                     break;
 832                 default:
 833                     state = INIT;
 834             }
 835             break;
 836         // Pause break: E1 F0 14 F0 77
 837         case E1_F0:
 838             switch (code) {
 839                 case 0x14:
 840                     state = E1_F0_14;
 841                     break;
 842                 default:
 843                     state = INIT;
 844             }
 845             break;
 846         case E1_F0_14:
 847             switch (code) {
 848                 case 0xF0:
 849                     state = E1_F0_14_F0;
 850                     break;
 851                 default:
 852                     state = INIT;
 853             }
 854             break;
 855         case E1_F0_14_F0:
 856             switch (code) {
 857                 case 0x77:
 858                     matrix_break(0x00);
 859                     state = INIT;
 860                     break;
 861                 default:
 862                     state = INIT;
 863             }
 864             break;
 865         default:
 866             state = INIT;
 867     }
 868     return 0;
 869 }
 870
 871 /*
 872  * Terminal: Scan Code Set 3
 873  *
 874  * See [3], [7] and
 875  * https://github.com/tmk/tmk_keyboard/wiki/IBM-PC-AT-Keyboard-Protocol#scan-code-set-3
 876  */
 877 static int8_t process_cs3(void)
 878 {
 879     static enum {
 880         READY,
 881         F0,
 882 #ifdef G80_2551_SUPPORT
 883         // G80-2551 four extra keys around cursor keys
 884         G80,
 885         G80_F0,
 886 #endif
 887     } state = READY;
 888
 889     uint16_t code = ibmpc_host_recv();
 890     if (code == -1) {
 891         return 0;
 892     }
 893
 894     switch (state) {
 895         case READY:
 896             switch (code) {
 897                 case 0x00:  // Error/Overrun [3]p.26
 898                     xprintf("!CS3_OVR!\n");
 899                     matrix_clear();
 900                     clear_keyboard();
 901                     break;
 902                 case 0xFF:
 903                     xprintf("!CS3_ERR!\n");
 904                     return -1;
 905                     break;
 906                 case 0xF0:
 907                     state = F0;
 908                     break;
 909                 case 0x83:  // PrintScreen
 910                     matrix_make(0x02);
 911                     break;
 912                 case 0x84:  // Keypad *
 913                     matrix_make(0x7F);
 914                     break;
 915                 case 0x85:  // Muhenkan
 916                     matrix_make(0x0B);
 917                     break;
 918                 case 0x86:  // Henkan
 919                     matrix_make(0x06);
 920                     break;
 921                 case 0x87:  // Hiragana
 922                     matrix_make(0x00);
 923                     break;
 924                 case 0x8B:  // Left GUI
 925                     matrix_make(0x01);
 926                     break;
 927                 case 0x8C:  // Right GUI
 928                     matrix_make(0x09);
 929                     break;
 930                 case 0x8D:  // Application
 931                     matrix_make(0x0A);
 932                     break;
 933 #ifdef G80_2551_SUPPORT
 934                 case 0x80:  // G80-2551 four extra keys around cursor keys
 935                     state = G80;
 936                     break;
 937 #endif
 938                 default:    // normal key make
 939                     if (code < 0x80) {
 940                         matrix_make(code);
 941                     } else {
 942                         xprintf("!CS3_READY!\n");
 943                         //return -1;
 944                     }
 945             }
 946             break;
 947         case F0:    // Break code
 948             switch (code) {
 949                 case 0x00:
 950                     xprintf("!CS3_F0_OVR!\n");
 951                     matrix_clear();
 952                     clear_keyboard();
 953                     state = READY;
 954                     break;
 955                 case 0xFF:
 956                     xprintf("!CS3_F0_ERR!\n");
 957                     state = READY;
 958                     return -1;
 959                     break;
 960                 case 0x83:  // PrintScreen
 961                     matrix_break(0x02);
 962                     state = READY;
 963                     break;
 964                 case 0x84:  // Keypad *
 965                     matrix_break(0x7F);
 966                     state = READY;
 967                     break;
 968                 case 0x85:  // Muhenkan
 969                     matrix_break(0x0B);
 970                     state = READY;
 971                     break;
 972                 case 0x86:  // Henkan
 973                     matrix_break(0x06);
 974                     state = READY;
 975                     break;
 976                 case 0x87:  // Hiragana
 977                     matrix_break(0x00);
 978                     state = READY;
 979                     break;
 980                 case 0x8B:  // Left GUI
 981                     matrix_break(0x01);
 982                     state = READY;
 983                     break;
 984                 case 0x8C:  // Right GUI
 985                     matrix_break(0x09);
 986                     state = READY;
 987                     break;
 988                 case 0x8D:  // Application
 989                     matrix_break(0x0A);
 990                     state = READY;
 991                     break;
 992                 default:
 993                     state = READY;
 994                     if (code < 0x80) {
 995                         matrix_break(code);
 996                     } else {
 997                         xprintf("!CS3_F0!\n");
 998                         //return -1;
 999                     }
1000             }
1001             break;
1002 #ifdef G80_2551_SUPPORT
1003         /*
1004          * G80-2551 terminal keyboard support
1005          * https://deskthority.net/wiki/Cherry_G80-2551
1006          * https://github.com/tmk/tmk_keyboard/wiki/IBM-PC-AT-Keyboard-Protocol#g80-2551-in-code-set-3
1007          */
1008         case G80:   // G80-2551 four extra keys around cursor keys
1009             switch (code) {
1010                 case (0x26):    // TD= -> JYEN
1011                     matrix_make(0x5D);
1012                     break;
1013                 case (0x25):    // page with edge -> NUHS
1014                     matrix_make(0x53);
1015                     break;
1016                 case (0x16):    // two pages -> RO
1017                     matrix_make(0x51);
1018                     break;
1019                 case (0x1E):    // calc -> KANA
1020                     matrix_make(0x00);
1021                     break;
1022                 case (0xF0):
1023                     state = G80_F0;
1024                     return 0;
1025                 default:
1026                     // Not supported
1027                     matrix_clear();
1028                     break;
1029             }
1030             state = READY;
1031             break;
1032         case G80_F0:
1033             switch (code) {
1034                 case (0x26):    // TD= -> JYEN
1035                     matrix_break(0x5D);
1036                     break;
1037                 case (0x25):    // page with edge -> NUHS
1038                     matrix_break(0x53);
1039                     break;
1040                 case (0x16):    // two pages -> RO
1041                     matrix_break(0x51);
1042                     break;
1043                 case (0x1E):    // calc -> KANA
1044                     matrix_break(0x00);
1045                     break;
1046                 default:
1047                     // Not supported
1048                     matrix_clear();
1049                     break;
1050             }
1051             state = READY;
1052             break;
1053 #endif
1054     }
1055     return 0;
1056 }
1057
1058 /*
1059  * IBM PC Keyboard Protocol Resources:
1060  *
1061  * [a] Microsoft USB HID to PS/2 Translation Table - Scan Code Set 1 and 2
1062  * http://download.microsoft.com/download/1/6/1/161ba512-40e2-4cc9-843a-923143f3456c/translate.pdf
1063  *
1064  * [b] Microsoft Keyboard Scan Code Specification - Special rules of Scan Code Set 1 and 2
1065  * http://download.microsoft.com/download/1/6/1/161ba512-40e2-4cc9-843a-923143f3456c/scancode.doc
1066  *
1067  * [1] PS/2 Reference Manuals - Collection of IBM Personal System/2 documents.
1068  * http://www.mcamafia.de/pdf/pdfref.htm
1069  *
1070  * [2] Keyboard and Auxiliary Device Controller - Signal Timing and Format
1071  * http://www.mcamafia.de/pdf/ibm_hitrc07.pdf
1072  *
1073  * [3] Keyboards(101- and 102-key) - Keyboard Layout, Scan Code Set, POR, and Commands.
1074  * http://www.mcamafia.de/pdf/ibm_hitrc11.pdf
1075  *
1076  * [4] IBM PC XT Keyboard Protocol
1077  * https://github.com/tmk/tmk_keyboard/wiki/IBM-PC-XT-Keyboard-Protocol
1078  *
1079  * [5] IBM Keyboard Scan Code by John Elliott - 83-key, 84-key, 102-key and 122-key
1080  * https://www.seasip.info/VintagePC/index.html
1081  *
1082  * [6] IBM 1391406 Keyboard - Scan Code Set 2 of 102-key PS/2 keyboard
1083  * https://www.seasip.info/VintagePC/ibm_1391406.html
1084  *
1085  * [7] The IBM 6110344 Keyboard - Scan Code Set 3 of 122-key terminal keyboard
1086  * https://www.seasip.info/VintagePC/ibm_6110344.html
1087  *
1088  * [8] IBM PC AT Technical Reference 1986
1089  * http://bitsavers.org/pdf/ibm/pc/at/6183355_PC_AT_Technical_Reference_Mar86.pdf
1090  *
1091  * [y] TrackPoint Engineering Specifications for version 3E
1092  * https://web.archive.org/web/20100526161812/http://wwwcssrv.almaden.ibm.com/trackpoint/download.html
1093  *
1094  * [z] [Soarer's XT/AT/PS2/Terminal to USB converter]
1095  * https://geekhack.org/index.php?topic=17458.0
1096  *
1097  */