converter/ps2_usb/matrix.c

   1 /*
   2 Copyright 2011 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 "action.h"
  21 #include "print.h"
  22 #include "util.h"
  23 #include "debug.h"
  24 #include "ps2.h"
  25 #include "host.h"
  26 #include "led.h"
  27 #include "matrix.h"
  28
  29
  30 static void matrix_make(uint8_t code);
  31 static void matrix_break(uint8_t code);
  32 static void matrix_clear(void);
  33 #ifdef MATRIX_HAS_GHOST
  34 static bool matrix_has_ghost_in_row(uint8_t row);
  35 #endif
  36
  37
  38 /*
  39  * Matrix Array usage:
  40  * 'Scan Code Set 2' is assigned into 256(32x8)cell matrix.
  41  * Hmm, it is very sparse and not efficient :(
  42  *
  43  * Notes:
  44  * Both 'Hanguel/English'(F1) and 'Hanja'(F2) collide with 'Delete'(E0 71) and 'Down'(E0 72).
  45  * These two Korean keys need exceptional handling and are not supported for now. Sorry.
  46  *
  47  *    8bit wide
  48  *   +---------+
  49  *  0|         |
  50  *  :|   XX    | 00-7F for normal codes(without E0-prefix)
  51  *  f|_________|
  52  * 10|         |
  53  *  :|  E0 YY  | 80-FF for E0-prefixed codes
  54  * 1f|         |     (<YY>|0x80) is used as matrix position.
  55  *   +---------+
  56  *
  57  * Exceptions:
  58  * 0x83:    F7(0x83) This is a normal code but beyond  0x7F.
  59  * 0xFC:    PrintScreen
  60  * 0xFE:    Pause
  61  */
  62 static uint8_t matrix[MATRIX_ROWS];
  63 #define ROW(code)      (code>>3)
  64 #define COL(code)      (code&0x07)
  65
  66 // matrix positions for exceptional keys
  67 #define F7             (0x83)
  68 #define PRINT_SCREEN   (0xFC)
  69 #define PAUSE          (0xFE)
  70
  71 static bool is_modified = false;
  72
  73
  74 inline
  75 uint8_t matrix_rows(void)
  76 {
  77     return MATRIX_ROWS;
  78 }
  79
  80 inline
  81 uint8_t matrix_cols(void)
  82 {
  83     return MATRIX_COLS;
  84 }
  85
  86 void matrix_init(void)
  87 {
  88     debug_enable = true;
  89     ps2_host_init();
  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  * PS/2 Scan Code Set 2: Exceptional Handling
  99  *
 100  * There are several keys to be handled exceptionally.
 101  * The scan code for these keys are varied or prefix/postfix'd
 102  * depending on modifier key state.
 103  *
 104  * Keyboard Scan Code Specification:
 105  *     http://www.microsoft.com/whdc/archive/scancode.mspx
 106  *     http://download.microsoft.com/download/1/6/1/161ba512-40e2-4cc9-843a-923143f3456c/scancode.doc
 107  *
 108  *
 109  * 1) Insert, Delete, Home, End, PageUp, PageDown, Up, Down, Right, Left
 110  *     a) when Num Lock is off
 111  *     modifiers | make                      | break
 112  *     ----------+---------------------------+----------------------
 113  *     Ohter     |                    <make> | <break>
 114  *     LShift    | E0 F0 12           <make> | <break>  E0 12
 115  *     RShift    | E0 F0 59           <make> | <break>  E0 59
 116  *     L+RShift  | E0 F0 12  E0 F0 59 <make> | <break>  E0 59 E0 12
 117  *
 118  *     b) when Num Lock is on
 119  *     modifiers | make                      | break
 120  *     ----------+---------------------------+----------------------
 121  *     Other     | E0 12              <make> | <break>  E0 F0 12
 122  *     Shift'd   |                    <make> | <break>
 123  *
 124  *     Handling: These prefix/postfix codes are ignored.
 125  *
 126  *
 127  * 2) Keypad /
 128  *     modifiers | make                      | break
 129  *     ----------+---------------------------+----------------------
 130  *     Ohter     |                    <make> | <break>
 131  *     LShift    | E0 F0 12           <make> | <break>  E0 12
 132  *     RShift    | E0 F0 59           <make> | <break>  E0 59
 133  *     L+RShift  | E0 F0 12  E0 F0 59 <make> | <break>  E0 59 E0 12
 134  *
 135  *     Handling: These prefix/postfix codes are ignored.
 136  *
 137  *
 138  * 3) PrintScreen
 139  *     modifiers | make         | break
 140  *     ----------+--------------+-----------------------------------
 141  *     Other     | E0 12  E0 7C | E0 F0 7C  E0 F0 12
 142  *     Shift'd   |        E0 7C | E0 F0 7C
 143  *     Control'd |        E0 7C | E0 F0 7C
 144  *     Alt'd     |           84 | F0 84
 145  *
 146  *     Handling: These prefix/postfix codes are ignored, and both scan codes
 147  *               'E0 7C' and 84 are seen as PrintScreen.
 148  *
 149  * 4) Pause
 150  *     modifiers | make(no break code)
 151  *     ----------+--------------------------------------------------
 152  *     Other     | E1 14 77 E1 F0 14 F0 77
 153  *     Control'd | E0 7E E0 F0 7E
 154  *
 155  *     Handling: Both code sequences are treated as a whole.
 156  *               And we need a ad hoc 'pseudo break code' hack to get the key off
 157  *               because it has no break code.
 158  *
 159  */
 160 uint8_t matrix_scan(void)
 161 {
 162
 163     // scan code reading states
 164     static enum {
 165         INIT,
 166         F0,
 167         E0,
 168         E0_F0,
 169         // Pause
 170         E1,
 171         E1_14,
 172         E1_14_77,
 173         E1_14_77_E1,
 174         E1_14_77_E1_F0,
 175         E1_14_77_E1_F0_14,
 176         E1_14_77_E1_F0_14_F0,
 177         // Control'd Pause
 178         E0_7E,
 179         E0_7E_E0,
 180         E0_7E_E0_F0,
 181     } state = INIT;
 182
 183
 184     is_modified = false;
 185
 186     // 'pseudo break code' hack
 187     if (matrix_is_on(ROW(PAUSE), COL(PAUSE))) {
 188         matrix_break(PAUSE);
 189     }
 190
 191     uint8_t code = ps2_host_recv();
 192     if (code) xprintf("%i\r\n", code);
 193     if (!ps2_error) {
 194         switch (state) {
 195             case INIT:
 196                 switch (code) {
 197                     case 0xE0:
 198                         state = E0;
 199                         break;
 200                     case 0xF0:
 201                         state = F0;
 202                         break;
 203                     case 0xE1:
 204                         state = E1;
 205                         break;
 206                     case 0x83:  // F7
 207                         matrix_make(F7);
 208                         state = INIT;
 209                         break;
 210                     case 0x84:  // Alt'd PrintScreen
 211                         matrix_make(PRINT_SCREEN);
 212                         state = INIT;
 213                         break;
 214                     case 0x00:  // Overrun [3]p.25
 215                         matrix_clear();
 216                         clear_keyboard();
 217                         print("Overrun\n");
 218                         state = INIT;
 219                         break;
 220                     case 0xAA:  // Self-test passed
 221                     case 0xFC:  // Self-test failed
 222                         printf("BAT %s\n", (code == 0xAA) ? "OK" : "NG");
 223                         led_set(host_keyboard_leds());
 224                         state = INIT;
 225                         break;
 226                     default:    // normal key make
 227                         if (code < 0x80) {
 228                             matrix_make(code);
 229                         } else {
 230                             matrix_clear();
 231                             clear_keyboard();
 232                             xprintf("unexpected scan code at INIT: %02X\n", code);
 233                         }
 234                         state = INIT;
 235                 }
 236                 break;
 237             case E0:    // E0-Prefixed
 238                 switch (code) {
 239                     case 0x12:  // to be ignored
 240                     case 0x59:  // to be ignored
 241                         state = INIT;
 242                         break;
 243                     case 0x7E:  // Control'd Pause
 244                         state = E0_7E;
 245                         break;
 246                     case 0xF0:
 247                         state = E0_F0;
 248                         break;
 249                     default:
 250                         if (code < 0x80) {
 251                             matrix_make(code|0x80);
 252                         } else {
 253                             matrix_clear();
 254                             clear_keyboard();
 255                             xprintf("unexpected scan code at E0: %02X\n", code);
 256                         }
 257                         state = INIT;
 258                 }
 259                 break;
 260             case F0:    // Break code
 261                 switch (code) {
 262                     case 0x83:  // F7
 263                         matrix_break(F7);
 264                         state = INIT;
 265                         break;
 266                     case 0x84:  // Alt'd PrintScreen
 267                         matrix_break(PRINT_SCREEN);
 268                         state = INIT;
 269                         break;
 270                     case 0xF0:
 271                         matrix_clear();
 272                         clear_keyboard();
 273                         xprintf("unexpected scan code at F0: F0(clear and cont.)\n");
 274                         break;
 275                     default:
 276                     if (code < 0x80) {
 277                         matrix_break(code);
 278                     } else {
 279                         matrix_clear();
 280                         clear_keyboard();
 281                         xprintf("unexpected scan code at F0: %02X\n", code);
 282                     }
 283                     state = INIT;
 284                 }
 285                 break;
 286             case E0_F0: // Break code of E0-prefixed
 287                 switch (code) {
 288                     case 0x12:  // to be ignored
 289                     case 0x59:  // to be ignored
 290                         state = INIT;
 291                         break;
 292                     default:
 293                         if (code < 0x80) {
 294                             matrix_break(code|0x80);
 295                         } else {
 296                             matrix_clear();
 297                             clear_keyboard();
 298                             xprintf("unexpected scan code at E0_F0: %02X\n", code);
 299                         }
 300                         state = INIT;
 301                 }
 302                 break;
 303             // following are states of Pause
 304             case E1:
 305                 switch (code) {
 306                     case 0x14:
 307                         state = E1_14;
 308                         break;
 309                     default:
 310                         state = INIT;
 311                 }
 312                 break;
 313             case E1_14:
 314                 switch (code) {
 315                     case 0x77:
 316                         state = E1_14_77;
 317                         break;
 318                     default:
 319                         state = INIT;
 320                 }
 321                 break;
 322             case E1_14_77:
 323                 switch (code) {
 324                     case 0xE1:
 325                         state = E1_14_77_E1;
 326                         break;
 327                     default:
 328                         state = INIT;
 329                 }
 330                 break;
 331             case E1_14_77_E1:
 332                 switch (code) {
 333                     case 0xF0:
 334                         state = E1_14_77_E1_F0;
 335                         break;
 336                     default:
 337                         state = INIT;
 338                 }
 339                 break;
 340             case E1_14_77_E1_F0:
 341                 switch (code) {
 342                     case 0x14:
 343                         state = E1_14_77_E1_F0_14;
 344                         break;
 345                     default:
 346                         state = INIT;
 347                 }
 348                 break;
 349             case E1_14_77_E1_F0_14:
 350                 switch (code) {
 351                     case 0xF0:
 352                         state = E1_14_77_E1_F0_14_F0;
 353                         break;
 354                     default:
 355                         state = INIT;
 356                 }
 357                 break;
 358             case E1_14_77_E1_F0_14_F0:
 359                 switch (code) {
 360                     case 0x77:
 361                         matrix_make(PAUSE);
 362                         state = INIT;
 363                         break;
 364                     default:
 365                         state = INIT;
 366                 }
 367                 break;
 368             // Following are states of Control'd Pause
 369             case E0_7E:
 370                 if (code == 0xE0)
 371                     state = E0_7E_E0;
 372                 else
 373                     state = INIT;
 374                 break;
 375             case E0_7E_E0:
 376                 if (code == 0xF0)
 377                     state = E0_7E_E0_F0;
 378                 else
 379                     state = INIT;
 380                 break;
 381             case E0_7E_E0_F0:
 382                 if (code == 0x7E)
 383                     matrix_make(PAUSE);
 384                 state = INIT;
 385                 break;
 386             default:
 387                 state = INIT;
 388         }
 389     }
 390
 391     // TODO: request RESEND when error occurs?
 392 /*
 393     if (PS2_IS_FAILED(ps2_error)) {
 394         uint8_t ret = ps2_host_send(PS2_RESEND);
 395         xprintf("Resend: %02X\n", ret);
 396     }
 397 */
 398     return 1;
 399 }
 400
 401 bool matrix_is_modified(void)
 402 {
 403     return is_modified;
 404 }
 405
 406 inline
 407 bool matrix_has_ghost(void)
 408 {
 409 #ifdef MATRIX_HAS_GHOST
 410     for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
 411         if (matrix_has_ghost_in_row(i))
 412             return true;
 413     }
 414 #endif
 415     return false;
 416 }
 417
 418 inline
 419 bool matrix_is_on(uint8_t row, uint8_t col)
 420 {
 421     return (matrix[row] & (1<<col));
 422 }
 423
 424 inline
 425 uint8_t matrix_get_row(uint8_t row)
 426 {
 427     return matrix[row];
 428 }
 429
 430 void matrix_print(void)
 431 {
 432     print("\nr/c 01234567\n");
 433     for (uint8_t row = 0; row < matrix_rows(); row++) {
 434         phex(row); print(": ");
 435         pbin_reverse(matrix_get_row(row));
 436 #ifdef MATRIX_HAS_GHOST
 437         if (matrix_has_ghost_in_row(row)) {
 438             print(" <ghost");
 439         }
 440 #endif
 441         print("\n");
 442     }
 443 }
 444
 445 uint8_t matrix_key_count(void)
 446 {
 447     uint8_t count = 0;
 448     for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
 449         count += bitpop(matrix[i]);
 450     }
 451     return count;
 452 }
 453
 454 #ifdef MATRIX_HAS_GHOST
 455 inline
 456 static bool matrix_has_ghost_in_row(uint8_t row)
 457 {
 458     // no ghost exists in case less than 2 keys on
 459     if (((matrix[row] - 1) & matrix[row]) == 0)
 460         return false;
 461
 462     // ghost exists in case same state as other row
 463     for (uint8_t i=0; i < MATRIX_ROWS; i++) {
 464         if (i != row && (matrix[i] & matrix[row]) == matrix[row])
 465             return true;
 466     }
 467     return false;
 468 }
 469 #endif
 470
 471
 472 inline
 473 static void matrix_make(uint8_t code)
 474 {
 475     if (!matrix_is_on(ROW(code), COL(code))) {
 476         matrix[ROW(code)] |= 1<<COL(code);
 477         is_modified = true;
 478     }
 479 }
 480
 481 inline
 482 static void matrix_break(uint8_t code)
 483 {
 484     if (matrix_is_on(ROW(code), COL(code))) {
 485         matrix[ROW(code)] &= ~(1<<COL(code));
 486         is_modified = true;
 487     }
 488 }
 489
 490 inline
 491 static void matrix_clear(void)
 492 {
 493     for (uint8_t i=0; i < MATRIX_ROWS; i++) matrix[i] = 0x00;
 494 }