converter/ibmpc_usb/ibmpc_usb.c

   1 /*
   2 Copyright 2019 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     code = read_wait(500);
  72     id |= code & 0xFF;
  73
  74 DONE:
  75     // Enable
  76     //code = ibmpc_host_send(0xF4);
  77
  78     return id;
  79 }
  80
  81 void hook_early_init(void)
  82 {
  83     ibmpc_host_init();
  84     ibmpc_host_enable();
  85 }
  86
  87 void matrix_init(void)
  88 {
  89     debug_enable = true;
  90
  91     // initialize matrix state: all keys off
  92     for (uint8_t i=0; i < MATRIX_ROWS; i++) matrix[i] = 0x00;
  93
  94     return;
  95 }
  96
  97 /*
  98  * keyboard recognition
  99  *
 100  * 1. Send F2 to get keyboard ID
 101  *      a. no ACK(FA): XT keyobard
 102  *      b. ACK but no ID: 84-key AT keyboard CodeSet2
 103  *      c. ID is AB 83: PS/2 keyboard CodeSet2
 104  *      d. ID is BF BF: Terminal keyboard CodeSet3
 105  *      e. error on recv: maybe broken PS/2
 106  */
 107 uint16_t keyboard_id = 0x0000;
 108 keyboard_kind_t keyboard_kind = NONE;
 109 uint8_t matrix_scan(void)
 110 {
 111     // scan code reading states
 112     static enum {
 113         INIT,
 114         XT_RESET,
 115         XT_RESET_WAIT,
 116         XT_RESET_DONE,
 117         WAIT_AA,
 118         WAIT_AABF,
 119         WAIT_AABFBF,
 120         READ_ID,
 121         SETUP,
 122         LOOP,
 123     } state = INIT;
 124     static uint16_t init_time;
 125
 126
 127     if (ibmpc_error) {
 128         xprintf("\nERR: %02X\n", ibmpc_error);
 129
 130         // when recv error, neither send error nor buffer full
 131         if (!(ibmpc_error & (IBMPC_ERR_SEND | IBMPC_ERR_FULL))) {
 132             // keyboard init again
 133             if (state == LOOP) {
 134                 xprintf("init\n");
 135                 state = INIT;
 136             }
 137         }
 138
 139         // clear or process error
 140         ibmpc_error = IBMPC_ERR_NONE;
 141     }
 142
 143     switch (state) {
 144         case INIT:
 145             xprintf("I%u ", timer_read());
 146             keyboard_kind = NONE;
 147             keyboard_id = 0x0000;
 148
 149             matrix_clear();
 150             clear_keyboard();
 151
 152             state = XT_RESET;
 153             break;
 154         case XT_RESET:
 155             // Reset XT-initialize keyboard
 156             // XT: hard reset 500ms for IBM XT Type-1 keyboard and clones
 157             // XT: soft reset 20ms min(clock Lo)
 158             ibmpc_host_disable();   // soft reset: inihibit(clock Lo/Data Hi)
 159             IBMPC_RST_LO();         // hard reset: reset pin Lo
 160
 161             init_time = timer_read();
 162             state = XT_RESET_WAIT;
 163             break;
 164         case XT_RESET_WAIT:
 165             if (timer_elapsed(init_time) > 500) {
 166                 state = XT_RESET_DONE;
 167             }
 168             break;
 169         case XT_RESET_DONE:
 170             IBMPC_RST_HIZ();        // hard reset: reset pin HiZ
 171             ibmpc_host_isr_clear();
 172             ibmpc_host_enable();    // soft reset: idle(clock Hi/Data Hi)
 173
 174             xprintf("X%u ", timer_read());
 175             init_time = timer_read();
 176             state = WAIT_AA;
 177             break;
 178         case WAIT_AA:
 179             // 1) Read BAT code and ID on keybaord power-up
 180             // For example, XT/AT sends 'AA' and Terminal sends 'AA BF BF' after BAT
 181             // AT 84-key: POR and BAT can take 900-9900ms according to AT TechRef [8] 4-7
 182             // AT 101/102-key: POR and BAT can take 450-2500ms according to AT TechRef [8] 4-39
 183             // 2) Read key typed by user or anything after error on protocol or scan code
 184             // This can happen in case of keyboard hotswap, unstable hardware, signal integrity problem or bug
 185
 186             if (timer_elapsed(init_time) > 10000) {
 187                 state = READ_ID;
 188             }
 189             if (ibmpc_host_recv() != -1) {  // wait for AA
 190                 xprintf("W%u ", timer_read());
 191                 init_time = timer_read();
 192                 state = WAIT_AABF;
 193             }
 194             break;
 195         case WAIT_AABF:
 196             // NOTE: we can omit to wait BF BF
 197             // ID takes 500ms max? TechRef [8] 4-41, though 1ms is enough for 122-key Terminal 6110345
 198             if (timer_elapsed(init_time) > 500) {
 199                 state = READ_ID;
 200             }
 201             if (ibmpc_host_recv() != -1) {  // wait for BF
 202                 xprintf("W%u ", timer_read());
 203                 init_time = timer_read();
 204                 state = WAIT_AABFBF;
 205             }
 206             break;
 207         case WAIT_AABFBF:
 208             if (timer_elapsed(init_time) > 500) {
 209                 state = READ_ID;
 210             }
 211             if (ibmpc_host_recv() != -1) {  // wait for BF
 212                 xprintf("W%u ", timer_read());
 213                 state = READ_ID;
 214             }
 215             break;
 216         case READ_ID:
 217             xprintf("R%u ", timer_read());
 218
 219             keyboard_id = read_keyboard_id();
 220             if (ibmpc_error) {
 221                 xprintf("\nERR: %02X\n", ibmpc_error);
 222                 ibmpc_error = IBMPC_ERR_NONE;
 223             }
 224
 225             if (0xAB00 == (keyboard_id & 0xFF00)) {         // CodeSet2 PS/2
 226                 keyboard_kind = PC_AT;
 227             } else if (0xBF00 == (keyboard_id & 0xFF00)) {  // CodeSet3 Terminal
 228                 keyboard_kind = PC_TERMINAL;
 229             } else if (0x0000 == keyboard_id) {             // CodeSet2 AT
 230                 keyboard_kind = PC_AT;
 231             } else if (0xFFFF == keyboard_id) {             // CodeSet1 XT
 232                 keyboard_kind = PC_XT;
 233             } else if (0xFFFE == keyboard_id) {             // CodeSet2 PS/2 fails to response?
 234                 keyboard_kind = PC_AT;
 235             } else if (0x00FF == keyboard_id) {             // Mouse is not supported
 236                 xprintf("Mouse: not supported\n");
 237                 keyboard_kind = NONE;
 238             } else {
 239                 keyboard_kind = PC_AT;
 240             }
 241
 242             xprintf("ID:%04X(%d)\n", keyboard_id, keyboard_kind);
 243
 244             state = SETUP;
 245             break;
 246         case SETUP:
 247             xprintf("S%u ", timer_read());
 248             switch (keyboard_kind) {
 249                 case PC_XT:
 250                     break;
 251                 case PC_AT:
 252                     led_set(host_keyboard_leds());
 253                     break;
 254                 case PC_TERMINAL:
 255                     ibmpc_host_send(0xF8);
 256                     break;
 257                 default:
 258                     break;
 259             }
 260             state = LOOP;
 261             xprintf("L%u ", timer_read());
 262         case LOOP:
 263             switch (keyboard_kind) {
 264                 case PC_XT:
 265                     if (process_cs1() == -1) state = INIT;
 266                     break;
 267                 case PC_AT:
 268                     if (process_cs2() == -1) state = INIT;
 269                     break;
 270                 case PC_TERMINAL:
 271                     if (process_cs3() == -1) state = INIT;
 272                     break;
 273                 default:
 274                     break;
 275             }
 276             break;
 277         default:
 278             break;
 279     }
 280     return 1;
 281 }
 282
 283 inline
 284 bool matrix_is_on(uint8_t row, uint8_t col)
 285 {
 286     return (matrix[row] & (1<<col));
 287 }
 288
 289 inline
 290 uint8_t matrix_get_row(uint8_t row)
 291 {
 292     return matrix[row];
 293 }
 294
 295 uint8_t matrix_key_count(void)
 296 {
 297     uint8_t count = 0;
 298     for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
 299         count += bitpop(matrix[i]);
 300     }
 301     return count;
 302 }
 303
 304
 305 inline
 306 static void matrix_make(uint8_t code)
 307 {
 308     if (!matrix_is_on(ROW(code), COL(code))) {
 309         matrix[ROW(code)] |= 1<<COL(code);
 310     }
 311 }
 312
 313 inline
 314 static void matrix_break(uint8_t code)
 315 {
 316     if (matrix_is_on(ROW(code), COL(code))) {
 317         matrix[ROW(code)] &= ~(1<<COL(code));
 318     }
 319 }
 320
 321 void matrix_clear(void)
 322 {
 323     for (uint8_t i=0; i < MATRIX_ROWS; i++) matrix[i] = 0x00;
 324 }
 325
 326 void led_set(uint8_t usb_led)
 327 {
 328     if (keyboard_kind != PC_AT) return;
 329
 330     uint8_t ibmpc_led = 0;
 331     if (usb_led &  (1<<USB_LED_SCROLL_LOCK))
 332         ibmpc_led |= (1<<IBMPC_LED_SCROLL_LOCK);
 333     if (usb_led &  (1<<USB_LED_NUM_LOCK))
 334         ibmpc_led |= (1<<IBMPC_LED_NUM_LOCK);
 335     if (usb_led &  (1<<USB_LED_CAPS_LOCK))
 336         ibmpc_led |= (1<<IBMPC_LED_CAPS_LOCK);
 337     ibmpc_host_set_led(ibmpc_led);
 338 }
 339
 340
 341 /*******************************************************************************
 342  * XT: Scan Code Set 1
 343  *
 344  * See [3], [a]
 345  *
 346  * E0-escaped scan codes are translated into unused range of the matrix.(54-7F)
 347  *
 348  *     01-53: Normal codes used in original XT keyboard
 349  *     54-7F: Not used in original XT keyboard
 350  *
 351  *         0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
 352  *     50  -   -   -   -   *   *   x   x   x   x   *   *   *   *   *   *
 353  *     60  *   *   *   *   x   x   x   x   x   x   x   x   x   x   x   *
 354  *     70  x   *   *   x   *   *   x   *   *   x   *   x   *   x   x   *
 355  *
 356  * -: codes existed in original XT keyboard
 357  * *: E0-escaped codes translated
 358  * x: Non-espcaped codes(Some are not used in real keyboards probably)
 359  *
 360  * Codes assigned in range 54-7F:
 361  *
 362  *     50  -                60  Up*                 70  KANAx
 363  *     51  -                61  Left*               71  Insert*
 364  *     52  -                62  Down*               72  Delete*
 365  *     53  -                63  Right*              73  ROx
 366  *     54  PrintScr*        64  F13x                74  Home*
 367  *     55  Pause*           65  F14x                75  End*
 368  *     56  Euro2x           66  F15x                76  F24x
 369  *     57  F11x             67  F16x                77  PageUp*
 370  *     58  F12x             68  F17x                78  PageDown*
 371  *     59  Keypad=x         69  F18x                79  HENKANx
 372  *     5A  LGUI*            6A  F19x                7A  RCTL*
 373  *     5B  RGUI*            6B  F20x                7B  MUHENKANx
 374  *     5C  APP*             6C  F21x                7C  RALT*
 375  *     5D  Mute*            6D  F22x                7D  JPYx
 376  *     5E  Volume Down*     6E  F23x                7E  Keypad,x
 377  *     5F  Volume Up*       6F  Keypad Enter*       7F  Keypad/ *
 378  */
 379 static uint8_t cs1_e0code(uint8_t code) {
 380     switch(code) {
 381         // Original IBM XT keyboard doesn't use E0-codes probably
 382         // Some XT compatilble keyobards need these keys?
 383         case 0x37: return 0x54; // Print Screen
 384         case 0x46: return 0x55; // Ctrl + Pause
 385         case 0x5B: return 0x5A; // Left  GUI
 386         case 0x5C: return 0x5B; // Right GUI
 387         case 0x5D: return 0x5C; // Application
 388         case 0x20: return 0x5D; // Mute
 389         case 0x2E: return 0x5E; // Volume Down
 390         case 0x30: return 0x5F; // Volume Up
 391         case 0x48: return 0x60; // Up
 392         case 0x4B: return 0x61; // Left
 393         case 0x50: return 0x62; // Down
 394         case 0x4D: return 0x63; // Right
 395         case 0x1C: return 0x6F; // Keypad Enter
 396         case 0x52: return 0x71; // Insert
 397         case 0x53: return 0x72; // Delete
 398         case 0x47: return 0x74; // Home
 399         case 0x4F: return 0x75; // End
 400         case 0x49: return 0x77; // Page Up
 401         case 0x51: return 0x78; // Page Down
 402         case 0x1D: return 0x7A; // Right Ctrl
 403         case 0x38: return 0x7C; // Right Alt
 404         case 0x35: return 0x7F; // Keypad /
 405
 406         // Shared matrix cell with other keys
 407         case 0x5E: return 0x70; // Power (KANA)
 408         case 0x5F: return 0x79; // Sleep (HENKAN)
 409         case 0x63: return 0x7B; // Wake  (MUHENKAN)
 410
 411         default:
 412            xprintf("!CS1_?!\n");
 413            return code;
 414     }
 415     return 0x00;
 416 }
 417
 418 static int8_t process_cs1(void)
 419 {
 420     static enum {
 421         INIT,
 422         E0,
 423         // Pause: E1 1D 45, E1 9D C5
 424         E1,
 425         E1_1D,
 426         E1_9D,
 427     } state = INIT;
 428
 429     uint16_t code = ibmpc_host_recv();
 430     if (code == -1) {
 431         return 0;
 432     }
 433
 434     switch (state) {
 435         case INIT:
 436             switch (code) {
 437                 case 0x00:
 438                 case 0xFF:  // Error/Overrun [3]p.26
 439                     xprintf("!CS1_%02X!\n", code);
 440                     return -1;
 441                     break;
 442                 case 0xE0:
 443                     state = E0;
 444                     break;
 445                 case 0xE1:
 446                     state = E1;
 447                     break;
 448                 default:
 449                     if (code < 0x80)
 450                         matrix_make(code);
 451                     else
 452                         matrix_break(code & 0x7F);
 453                     break;
 454             }
 455             break;
 456         case E0:
 457             switch (code) {
 458                 case 0x2A:
 459                 case 0xAA:
 460                 case 0x36:
 461                 case 0xB6:
 462                     //ignore fake shift
 463                     state = INIT;
 464                     break;
 465                 default:
 466                     if (code < 0x80)
 467                         matrix_make(cs1_e0code(code));
 468                     else
 469                         matrix_break(cs1_e0code(code & 0x7F));
 470                     state = INIT;
 471                     break;
 472             }
 473             break;
 474         case E1:
 475             switch (code) {
 476                 case 0x1D:
 477                     state = E1_1D;
 478                     break;
 479                 case 0x9D:
 480                     state = E1_9D;
 481                     break;
 482                 default:
 483                     state = INIT;
 484                     break;
 485             }
 486             break;
 487         case E1_1D:
 488             switch (code) {
 489                 case 0x45:
 490                     matrix_make(0x55);
 491                     break;
 492                 default:
 493                     state = INIT;
 494                     break;
 495             }
 496             break;
 497         case E1_9D:
 498             switch (code) {
 499                 case 0x45:
 500                     matrix_break(0x55);
 501                     break;
 502                 default:
 503                     state = INIT;
 504                     break;
 505             }
 506             break;
 507         default:
 508             state = INIT;
 509     }
 510     return 0;
 511 }
 512
 513
 514 /*******************************************************************************
 515  * AT, PS/2: Scan Code Set 2
 516  *
 517  * Exceptional Handling
 518  * --------------------
 519  * Some keys should be handled exceptionally. See [b].
 520  *
 521  * Scan codes are varied or prefix/postfix'd depending on modifier key state.
 522  *
 523  * 1) Insert, Delete, Home, End, PageUp, PageDown, Up, Down, Right, Left
 524  *     a) when Num Lock is off
 525  *     modifiers | make                      | break
 526  *     ----------+---------------------------+----------------------
 527  *     Ohter     |                    <make> | <break>
 528  *     LShift    | E0 F0 12           <make> | <break>  E0 12
 529  *     RShift    | E0 F0 59           <make> | <break>  E0 59
 530  *     L+RShift  | E0 F0 12  E0 F0 59 <make> | <break>  E0 59 E0 12
 531  *
 532  *     b) when Num Lock is on
 533  *     modifiers | make                      | break
 534  *     ----------+---------------------------+----------------------
 535  *     Other     | E0 12              <make> | <break>  E0 F0 12
 536  *     Shift'd   |                    <make> | <break>
 537  *
 538  *     Handling: These prefix/postfix codes are ignored.
 539  *
 540  *
 541  * 2) Keypad /
 542  *     modifiers | make                      | break
 543  *     ----------+---------------------------+----------------------
 544  *     Ohter     |                    <make> | <break>
 545  *     LShift    | E0 F0 12           <make> | <break>  E0 12
 546  *     RShift    | E0 F0 59           <make> | <break>  E0 59
 547  *     L+RShift  | E0 F0 12  E0 F0 59 <make> | <break>  E0 59 E0 12
 548  *
 549  *     Handling: These prefix/postfix codes are ignored.
 550  *
 551  *
 552  * 3) PrintScreen
 553  *     modifiers | make         | break
 554  *     ----------+--------------+-----------------------------------
 555  *     Other     | E0 12  E0 7C | E0 F0 7C  E0 F0 12
 556  *     Shift'd   |        E0 7C | E0 F0 7C
 557  *     Control'd |        E0 7C | E0 F0 7C
 558  *     Alt'd     |           84 | F0 84
 559  *
 560  *     Handling: These prefix/postfix codes are ignored, and both scan codes
 561  *               'E0 7C' and 84 are seen as PrintScreen.
 562  *
 563  * 4) Pause
 564  *     modifiers | make(no break code)
 565  *     ----------+--------------------------------------------------
 566  *     Other     | E1 14 77 E1 F0 14 F0 77
 567  *     Control'd | E0 7E E0 F0 7E
 568  *
 569  *     Handling: Both code sequences are treated as a whole.
 570  *               And we need a ad hoc 'pseudo break code' hack to get the key off
 571  *               because it has no break code.
 572  *
 573  * Notes:
 574  * 'Hanguel/English'(F1) and 'Hanja'(F2) have no break code. See [a].
 575  * These two Korean keys need exceptional handling and are not supported for now.
 576  *
 577  */
 578 static uint8_t cs2_e0code(uint8_t code) {
 579     switch(code) {
 580         // E0 prefixed codes translation See [a].
 581         case 0x11: return 0x0F; // right alt
 582         case 0x14: return 0x17; // right control
 583         case 0x1F: return 0x19; // left GUI
 584         case 0x27: return 0x1F; // right GUI
 585         case 0x2F: return 0x5C; // apps
 586         case 0x4A: return 0x60; // keypad /
 587         case 0x5A: return 0x62; // keypad enter
 588         case 0x69: return 0x27; // end
 589         case 0x6B: return 0x53; // cursor left
 590         case 0x6C: return 0x2F; // home
 591         case 0x70: return 0x39; // insert
 592         case 0x71: return 0x37; // delete
 593         case 0x72: return 0x3F; // cursor down
 594         case 0x74: return 0x47; // cursor right
 595         case 0x75: return 0x4F; // cursor up
 596         case 0x7A: return 0x56; // page down
 597         case 0x7D: return 0x5E; // page up
 598         case 0x7C: return 0x6F; // Print Screen
 599         case 0x7E: return 0x00; // Control'd Pause
 600
 601         case 0x21: return 0x65; // volume down
 602         case 0x32: return 0x6E; // volume up
 603         case 0x23: return 0x7F; // mute
 604         case 0x10: return 0x08; // (WWW search)     -> F13
 605         case 0x18: return 0x10; // (WWW favourites) -> F14
 606         case 0x20: return 0x18; // (WWW refresh)    -> F15
 607         case 0x28: return 0x20; // (WWW stop)       -> F16
 608         case 0x30: return 0x28; // (WWW forward)    -> F17
 609         case 0x38: return 0x30; // (WWW back)       -> F18
 610         case 0x3A: return 0x38; // (WWW home)       -> F19
 611         case 0x40: return 0x40; // (my computer)    -> F20
 612         case 0x48: return 0x48; // (email)          -> F21
 613         case 0x2B: return 0x50; // (calculator)     -> F22
 614         case 0x34: return 0x08; // (play/pause)     -> F13
 615         case 0x3B: return 0x10; // (stop)           -> F14
 616         case 0x15: return 0x18; // (previous track) -> F15
 617         case 0x4D: return 0x20; // (next track)     -> F16
 618         case 0x50: return 0x28; // (media select)   -> F17
 619         case 0x5E: return 0x50; // (ACPI wake)      -> F22
 620         case 0x3F: return 0x57; // (ACPI sleep)     -> F23
 621         case 0x37: return 0x5F; // (ACPI power)     -> F24
 622
 623         // https://github.com/tmk/tmk_keyboard/pull/636
 624         case 0x03: return 0x18; // Help        DEC LK411 -> F15
 625         case 0x04: return 0x08; // F13         DEC LK411
 626         case 0x0B: return 0x20; // Do          DEC LK411 -> F16
 627         case 0x0C: return 0x10; // F14         DEC LK411
 628         case 0x0D: return 0x19; // LCompose    DEC LK411 -> LGUI
 629         case 0x79: return 0x6D; // KP-         DEC LK411 -> PCMM
 630         case 0x83: return 0x28; // F17         DEC LK411
 631         default: return (code & 0x7F);
 632     }
 633 }
 634
 635 static int8_t process_cs2(void)
 636 {
 637     // scan code reading states
 638     static enum {
 639         INIT,
 640         F0,
 641         E0,
 642         E0_F0,
 643         // Pause
 644         E1,
 645         E1_14,
 646         E1_F0,
 647         E1_F0_14,
 648         E1_F0_14_F0,
 649     } state = INIT;
 650
 651     uint16_t code = ibmpc_host_recv();
 652     if (code == -1) {
 653         return 0;
 654     }
 655
 656     switch (state) {
 657         case INIT:
 658             switch (code) {
 659                 case 0x00:  // Error/Overrun [3]p.26
 660                 case 0xFF:
 661                     matrix_clear();
 662                     xprintf("!CS2_%02X!\n", code);
 663                     state = INIT;
 664                     return -1;
 665                     break;
 666                 case 0xE0:
 667                     state = E0;
 668                     break;
 669                 case 0xF0:
 670                     state = F0;
 671                     break;
 672                 case 0xE1:
 673                     state = E1;
 674                     break;
 675                 case 0x83:  // F7
 676                     matrix_make(0x02);
 677                     state = INIT;
 678                     break;
 679                 case 0x84:  // Alt'd PrintScreen
 680                     matrix_make(0x6F);
 681                     state = INIT;
 682                     break;
 683                 case 0xAA:  // Self-test passed
 684                 case 0xFC:  // Self-test failed
 685                     // reset or plugin-in new keyboard
 686                     state = INIT;
 687                     return -1;
 688                     break;
 689                 default:    // normal key make
 690                     state = INIT;
 691                     if (code < 0x80) {
 692                         matrix_make(code);
 693                     } else {
 694                         matrix_clear();
 695                         xprintf("!CS2_INIT!\n");
 696                         return -1;
 697                     }
 698             }
 699             break;
 700         case E0:    // E0-Prefixed
 701             switch (code) {
 702                 case 0x12:  // to be ignored
 703                 case 0x59:  // to be ignored
 704                     state = INIT;
 705                     break;
 706                 case 0xF0:
 707                     state = E0_F0;
 708                     break;
 709                 default:
 710                     state = INIT;
 711                     if (code < 0x80) {
 712                         matrix_make(cs2_e0code(code));
 713                     } else {
 714                         matrix_clear();
 715                         xprintf("!CS2_E0!\n");
 716                         return -1;
 717                     }
 718             }
 719             break;
 720         case F0:    // Break code
 721             switch (code) {
 722                 case 0x83:  // F7
 723                     matrix_break(0x02);
 724                     state = INIT;
 725                     break;
 726                 case 0x84:  // Alt'd PrintScreen
 727                     matrix_break(0x6F);
 728                     state = INIT;
 729                     break;
 730                 default:
 731                     state = INIT;
 732                     if (code < 0x80) {
 733                         matrix_break(code);
 734                     } else {
 735                         matrix_clear();
 736                         xprintf("!CS2_F0!\n");
 737                         return -1;
 738                     }
 739             }
 740             break;
 741         case E0_F0: // Break code of E0-prefixed
 742             switch (code) {
 743                 case 0x12:  // to be ignored
 744                 case 0x59:  // to be ignored
 745                     state = INIT;
 746                     break;
 747                 default:
 748                     state = INIT;
 749                     if (code < 0x80) {
 750                         matrix_break(cs2_e0code(code));
 751                     } else {
 752                         matrix_clear();
 753                         xprintf("!CS2_E0_F0!\n");
 754                         return -1;
 755                     }
 756             }
 757             break;
 758         // Pause make: E1 14 77
 759         case E1:
 760             switch (code) {
 761                 case 0x14:
 762                     state = E1_14;
 763                     break;
 764                 case 0xF0:
 765                     state = E1_F0;
 766                     break;
 767                 default:
 768                     state = INIT;
 769             }
 770             break;
 771         case E1_14:
 772             switch (code) {
 773                 case 0x77:
 774                     matrix_make(0x00);
 775                     state = INIT;
 776                     break;
 777                 default:
 778                     state = INIT;
 779             }
 780             break;
 781         // Pause break: E1 F0 14 F0 77
 782         case E1_F0:
 783             switch (code) {
 784                 case 0x14:
 785                     state = E1_F0_14;
 786                     break;
 787                 default:
 788                     state = INIT;
 789             }
 790             break;
 791         case E1_F0_14:
 792             switch (code) {
 793                 case 0xF0:
 794                     state = E1_F0_14_F0;
 795                     break;
 796                 default:
 797                     state = INIT;
 798             }
 799             break;
 800         case E1_F0_14_F0:
 801             switch (code) {
 802                 case 0x77:
 803                     matrix_break(0x00);
 804                     state = INIT;
 805                     break;
 806                 default:
 807                     state = INIT;
 808             }
 809             break;
 810         default:
 811             state = INIT;
 812     }
 813     return 0;
 814 }
 815
 816 /*
 817  * Terminal: Scan Code Set 3
 818  *
 819  * See [3], [7]
 820  *
 821  * Scan code 0x83 and 0x84 are handled exceptioanally to fit into 1-byte range index.
 822  */
 823 static int8_t process_cs3(void)
 824 {
 825     static enum {
 826         READY,
 827         F0,
 828     } state = READY;
 829
 830     uint16_t code = ibmpc_host_recv();
 831     if (code == -1) {
 832         return 0;
 833     }
 834
 835     switch (state) {
 836         case READY:
 837             switch (code) {
 838                 case 0x00:  // Error/Overrun [3]p.26
 839                 case 0xFF:
 840                     xprintf("!CS3_%02X!\n", code);
 841                     return -1;
 842                     break;
 843                 case 0xF0:
 844                     state = F0;
 845                     break;
 846                 case 0x83:  // F7
 847                     matrix_make(0x02);
 848                     break;
 849                 case 0x84:  // keypad -
 850                     matrix_make(0x7F);
 851                     break;
 852                 default:    // normal key make
 853                     if (code < 0x80) {
 854                         matrix_make(code);
 855                     } else {
 856                         xprintf("!CS3_%02X!\n", code);
 857                         return -1;
 858                     }
 859             }
 860             break;
 861         case F0:    // Break code
 862             switch (code) {
 863                 case 0x00:
 864                 case 0xFF:
 865                     xprintf("!CS3_F0_%02X!\n", code);
 866                     state = READY;
 867                     return -1;
 868                     break;
 869                 case 0x83:  // F7
 870                     matrix_break(0x02);
 871                     state = READY;
 872                     break;
 873                 case 0x84:  // keypad -
 874                     matrix_break(0x7F);
 875                     state = READY;
 876                     break;
 877                 default:
 878                     state = READY;
 879                     if (code < 0x80) {
 880                         matrix_break(code);
 881                     } else {
 882                         xprintf("!CS3_F0_%02X!\n", code);
 883                         return -1;
 884                     }
 885             }
 886             break;
 887     }
 888     return 0;
 889 }
 890
 891 /*
 892  * IBM PC Keyboard Protocol Resources:
 893  *
 894  * [a] Microsoft USB HID to PS/2 Translation Table - Scan Code Set 1 and 2
 895  * http://download.microsoft.com/download/1/6/1/161ba512-40e2-4cc9-843a-923143f3456c/translate.pdf
 896  *
 897  * [b] Microsoft Keyboard Scan Code Specification - Special rules of Scan Code Set 1 and 2
 898  * http://download.microsoft.com/download/1/6/1/161ba512-40e2-4cc9-843a-923143f3456c/scancode.doc
 899  *
 900  * [1] PS/2 Reference Manuals - Collection of IBM Personal System/2 documents.
 901  * http://www.mcamafia.de/pdf/pdfref.htm
 902  *
 903  * [2] Keyboard and Auxiliary Device Controller - Signal Timing and Format
 904  * http://www.mcamafia.de/pdf/ibm_hitrc07.pdf
 905  *
 906  * [3] Keyboards(101- and 102-key) - Keyboard Layout, Scan Code Set, POR, and Commands.
 907  * http://www.mcamafia.de/pdf/ibm_hitrc11.pdf
 908  *
 909  * [4] IBM PC XT Keyboard Protocol
 910  * https://github.com/tmk/tmk_keyboard/wiki/IBM-PC-XT-Keyboard-Protocol
 911  *
 912  * [5] IBM Keyboard Scan Code by John Elliott - 83-key, 84-key, 102-key and 122-key
 913  * https://www.seasip.info/VintagePC/index.html
 914  *
 915  * [6] IBM 1391406 Keyboard - Scan Code Set 2 of 102-key PS/2 keyboard
 916  * https://www.seasip.info/VintagePC/ibm_1391406.html
 917  *
 918  * [7] The IBM 6110344 Keyboard - Scan Code Set 3 of 122-key terminal keyboard
 919  * https://www.seasip.info/VintagePC/ibm_6110344.html
 920  *
 921  * [y] TrackPoint Engineering Specifications for version 3E
 922  * https://web.archive.org/web/20100526161812/http://wwwcssrv.almaden.ibm.com/trackpoint/download.html
 923  *
 924  * [z] [Soarer's XT/AT/PS2/Terminal to USB converter]
 925  * https://geekhack.org/index.php?topic=17458.0
 926  *
 927  */