common/keyboard.c

   1 /*
   2 Copyright 2011,2012 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 #include "keyboard.h"
  18 #include "matrix.h"
  19 #include "keymap.h"
  20 #include "host.h"
  21 #include "led.h"
  22 #include "keycode.h"
  23 #include "timer.h"
  24 #include "print.h"
  25 #include "debug.h"
  26 #include "command.h"
  27 #include "util.h"
  28 #include "sendchar.h"
  29 #ifdef MOUSEKEY_ENABLE
  30 #include "mousekey.h"
  31 #endif
  32
  33
  34 #define Kdebug(s)       do { if (debug_keyboard) debug(s); } while(0)
  35 #define Kdebug_P(s)     do { if (debug_keyboard) debug_P(s); } while(0)
  36 #define Kdebug_hex(s)   do { if (debug_keyboard) debug_hex(s); } while(0)
  37
  38 #define LAYER_DELAY     250
  39
  40 typedef enum keykind {
  41     NONE,
  42     FN_DOWN, FN_UP,
  43     FNK_DOWN, FNK_UP,
  44     KEY_DOWN, KEY_UP,
  45     MOD_DOWN, MOD_UP,
  46 } keykind_t;
  47
  48 typedef enum { IDLE, DELAYING, WAITING, PRESSING } kbdstate_t;
  49
  50
  51 #ifdef KEYMAP_DEFAULT_LAYER
  52 uint8_t default_layer = KEYMAP_DEFAULT_LAYER;
  53 uint8_t current_layer = KEYMAP_DEFAULT_LAYER;
  54 #else
  55 uint8_t default_layer = 0;
  56 uint8_t current_layer = 0;
  57 #endif
  58
  59 /* keyboard internal states */
  60 static kbdstate_t kbdstate = IDLE;
  61 static uint8_t fn_state_bits = 0;
  62 static keyrecord_t delayed_fn;
  63 static keyrecord_t waiting_key;
  64
  65
  66 static const char *state_str(kbdstate_t state)
  67 {
  68     if (state == IDLE)      return PSTR("IDLE");
  69     if (state == DELAYING)  return PSTR("DELAYING");
  70     if (state == WAITING)   return PSTR("WAITING");
  71     if (state == PRESSING)  return PSTR("PRESSING");
  72     return PSTR("UNKNOWN");
  73 }
  74
  75 static inline keykind_t get_keykind(uint8_t code, bool pressed)
  76 {
  77     if IS_KEY(code)         return (pressed ? KEY_DOWN : KEY_UP);
  78     if IS_MOD(code)         return (pressed ? MOD_DOWN : MOD_UP);
  79     if IS_FN(code) {
  80         if (keymap_fn_keycode(FN_INDEX(code)))
  81             return (pressed ? FNK_DOWN : FNK_UP);
  82         else
  83             return (pressed ? FN_DOWN : FN_UP);
  84     }
  85     if IS_MOUSEKEY(code)    return (pressed ? KEY_DOWN : KEY_UP);
  86     if IS_SYSTEM(code)      return (pressed ? KEY_DOWN : KEY_UP);
  87     if IS_CONSUMER(code)    return (pressed ? KEY_DOWN : KEY_UP);
  88     return  NONE;
  89 }
  90
  91 static void clear_keyboard(void)
  92 {
  93     host_clear_keys();
  94     host_clear_mods();
  95     host_send_keyboard_report();
  96
  97     host_system_send(0);
  98     host_consumer_send(0);
  99
 100 #ifdef MOUSEKEY_ENABLE
 101     mousekey_clear();
 102     mousekey_send();
 103 #endif
 104 }
 105
 106 static void clear_keyboard_but_mods(void)
 107 {
 108     host_clear_keys();
 109     host_send_keyboard_report();
 110
 111     host_system_send(0);
 112     host_consumer_send(0);
 113
 114 #ifdef MOUSEKEY_ENABLE
 115     mousekey_clear();
 116     mousekey_send();
 117 #endif
 118 }
 119
 120 static bool anykey_sent_to_host(void)
 121 {
 122     return (host_has_anykey() || host_mouse_in_use() ||
 123             host_last_sysytem_report() || host_last_consumer_report());
 124 }
 125
 126 static void layer_switch_on(uint8_t code)
 127 {
 128     if (!IS_FN(code)) return;
 129     fn_state_bits |= FN_BIT(code);
 130     uint8_t new_layer = (fn_state_bits ? keymap_fn_layer(biton(fn_state_bits)) : default_layer);
 131     if (current_layer != new_layer) {
 132         Kdebug("Layer Switch(on): "); Kdebug_hex(current_layer);
 133         Kdebug(" -> "); Kdebug_hex(new_layer); Kdebug("\n");
 134
 135         clear_keyboard_but_mods();
 136         current_layer = new_layer;
 137     }
 138 }
 139
 140 static bool layer_switch_off(uint8_t code)
 141 {
 142     if (!IS_FN(code)) return false;
 143     fn_state_bits &= ~FN_BIT(code);
 144     uint8_t new_layer = (fn_state_bits ? keymap_fn_layer(biton(fn_state_bits)) : default_layer);
 145     if (current_layer != new_layer) {
 146         Kdebug("Layer Switch(off): "); Kdebug_hex(current_layer);
 147         Kdebug(" -> "); Kdebug_hex(new_layer); Kdebug("\n");
 148
 149         clear_keyboard_but_mods();
 150         current_layer = new_layer;
 151         return true;
 152     }
 153     return false;
 154 }
 155
 156 static void register_code(uint8_t code)
 157 {
 158     if IS_KEY(code) {
 159         if (!command_proc(code)) {
 160             host_add_key(code);
 161             host_send_keyboard_report();
 162         }
 163     }
 164     else if IS_MOD(code) {
 165         host_add_mod_bit(MOD_BIT(code));
 166         host_send_keyboard_report();
 167     }
 168     else if IS_FN(code) {
 169         if (!command_proc(keymap_fn_keycode(FN_INDEX(code)))) {
 170             host_add_key(keymap_fn_keycode(FN_INDEX(code)));
 171             host_send_keyboard_report();
 172         }
 173     }
 174     else if IS_MOUSEKEY(code) {
 175 #ifdef MOUSEKEY_ENABLE
 176         mousekey_on(code);
 177         mousekey_send();
 178 #endif
 179     }
 180     else if IS_CONSUMER(code) {
 181         uint16_t usage = 0;
 182         switch (code) {
 183             case KC_AUDIO_MUTE:
 184                 usage = AUDIO_MUTE;
 185                 break;
 186             case KC_AUDIO_VOL_UP:
 187                 usage = AUDIO_VOL_UP;
 188                 break;
 189             case KC_AUDIO_VOL_DOWN:
 190                 usage = AUDIO_VOL_DOWN;
 191                 break;
 192             case KC_MEDIA_NEXT_TRACK:
 193                 usage = TRANSPORT_NEXT_TRACK;
 194                 break;
 195             case KC_MEDIA_PREV_TRACK:
 196                 usage = TRANSPORT_PREV_TRACK;
 197                 break;
 198             case KC_MEDIA_STOP:
 199                 usage = TRANSPORT_STOP;
 200                 break;
 201             case KC_MEDIA_PLAY_PAUSE:
 202                 usage = TRANSPORT_PLAY_PAUSE;
 203                 break;
 204             case KC_MEDIA_SELECT:
 205                 usage = AL_CC_CONFIG;
 206                 break;
 207             case KC_MAIL:
 208                 usage = AL_EMAIL;
 209                 break;
 210             case KC_CALCULATOR:
 211                 usage = AL_CALCULATOR;
 212                 break;
 213             case KC_MY_COMPUTER:
 214                 usage = AL_LOCAL_BROWSER;
 215                 break;
 216             case KC_WWW_SEARCH:
 217                 usage = AC_SEARCH;
 218                 break;
 219             case KC_WWW_HOME:
 220                 usage = AC_HOME;
 221                 break;
 222             case KC_WWW_BACK:
 223                 usage = AC_BACK;
 224                 break;
 225             case KC_WWW_FORWARD:
 226                 usage = AC_FORWARD;
 227                 break;
 228             case KC_WWW_STOP:
 229                 usage = AC_STOP;
 230                 break;
 231             case KC_WWW_REFRESH:
 232                 usage = AC_REFRESH;
 233                 break;
 234             case KC_WWW_FAVORITES:
 235                 usage = AC_BOOKMARKS;
 236                 break;
 237         }
 238         host_consumer_send(usage);
 239     }
 240     else if IS_SYSTEM(code) {
 241         uint16_t usage = 0;
 242         switch (code) {
 243             case KC_SYSTEM_POWER:
 244                 usage = SYSTEM_POWER_DOWN;
 245                 break;
 246             case KC_SYSTEM_SLEEP:
 247                 usage = SYSTEM_SLEEP;
 248                 break;
 249             case KC_SYSTEM_WAKE:
 250                 usage = SYSTEM_WAKE_UP;
 251                 break;
 252         }
 253         host_system_send(usage);
 254     }
 255
 256 }
 257
 258 static void unregister_code(uint8_t code)
 259 {
 260     if IS_KEY(code) {
 261         host_del_key(code);
 262         host_send_keyboard_report();
 263     }
 264     else if IS_MOD(code) {
 265         host_del_mod_bit(MOD_BIT(code));
 266         host_send_keyboard_report();
 267     }
 268     else if IS_FN(code) {
 269         host_del_key(keymap_fn_keycode(FN_INDEX(code)));
 270         host_send_keyboard_report();
 271     }
 272     else if IS_MOUSEKEY(code) {
 273 #ifdef MOUSEKEY_ENABLE
 274         mousekey_off(code);
 275         mousekey_send();
 276 #endif
 277     }
 278     else if IS_CONSUMER(code) {
 279         host_consumer_send(0x0000);
 280     }
 281     else if IS_SYSTEM(code) {
 282         host_system_send(0x0000);
 283     }
 284 }
 285
 286 /*
 287  *
 288  * Event/State|IDLE          PRESSING      DELAYING[f]      WAITING[f,k]
 289  * -----------+------------------------------------------------------------------
 290  * Fn  Down   |(L+)          -*1           WAITING(Sk)      IDLE(Rf,Ps)*7
 291  *     Up     |(L-)          IDLE(L-)*8    IDLE(L-)*8       IDLE(L-)*8
 292  * Fnk Down   |DELAYING(Sf)* (Rf)          WAITING(Sk)      IDLE(Rf,Ps,Rf)
 293  *     Up     |(L-)          IDLE(L-/Uf)*8 IDLE(Rf,Uf/L-)*3 IDLE(Rf,Ps,Uf/L-)*3
 294  * Key Down   |PRESSING(Rk)  (Rk)          WAITING(Sk)      IDLE(Rf,Ps,Rk)
 295  *     Up     |(Uk)          IDLE(Uk)*4    (Uk)             IDLE(L+,Ps,Pk)/(Uk)*a
 296  *            |
 297  * Delay      |-             -             IDLE(L+)         IDLE(L+,Ps)
 298  * Magic Key  |COMMAND*5
 299  *
 300  * *1: ignore Fn if other key is down.
 301  * *2: register Fnk if any key is pressing
 302  * *3: register/unregister delayed Fnk and move to IDLE if code == delayed Fnk, else *8
 303  * *4: if no keys registered to host
 304  * *5: unregister all keys
 305  * *6: only if no keys down
 306  * *7: ignore Fn because Fnk key and stored key are down.
 307  * *8: move to IDLE if layer switch(off) occurs, else stay at current state
 308  * *9: repeat key if pressing Fnk twice quickly(move to PRESSING)
 309  * *a: layer switch and process waiting key and code if code == wainting key, else unregister key
 310  *
 311  * States:
 312  *      IDLE: No key is down except modifiers
 313  *      DELAYING: delay layer switch after pressing Fn with alt keycode
 314  *      WAITING: key is pressed during DELAYING
 315  *
 316  * Events:
 317  *      Fn: Fn key without alternative keycode
 318  *      Fnk: Fn key with alternative keycode
 319  *      -: ignore
 320  *      Delay: layer switch delay term is elapsed
 321  *
 322  * Actions:
 323  *      Rk: register key
 324  *      Uk: unregister key
 325  *      Rf: register Fn(alt keycode)
 326  *      Uf: unregister Fn(alt keycode)
 327  *      Rs: register stored key
 328  *      Us: unregister stored key
 329  *      Sk: Store key(waiting Key)
 330  *      Sf: Store Fn(delayed Fn)
 331  *      Ps: Process stored key
 332  *      Ps: Process key
 333  *      Is: Interpret stored keys in current layer
 334  *      L+: Switch to new layer(*unregister* all keys but modifiers)
 335  *      L-: Switch back to last layer(*unregister* all keys but modifiers)
 336  *      Ld: Switch back to default layer(*unregister* all keys but modifiers)
 337  */
 338 #define NEXT(state)     do { \
 339     Kdebug("NEXT: "); Kdebug_P(state_str(kbdstate)); \
 340     kbdstate = state; \
 341     Kdebug(" -> "); Kdebug_P(state_str(kbdstate)); Kdebug("\n"); \
 342 } while (0)
 343
 344 static inline void process_key(keyevent_t event)
 345 {
 346     uint8_t code = keymap_get_keycode(current_layer, event.key.row, event.key.col);
 347     keykind_t kind = get_keykind(code, event.pressed);
 348
 349     uint8_t tmp_mods;
 350
 351     Kdebug("state: "); Kdebug_P(state_str(kbdstate));
 352     Kdebug(" kind: "); Kdebug_hex(kind);
 353     Kdebug(" code: "); Kdebug_hex(code);
 354     if (event.pressed) { Kdebug("d"); } else { Kdebug("u"); }
 355     Kdebug("\n");
 356
 357     switch (kbdstate) {
 358         case IDLE:
 359             switch (kind) {
 360                 case FN_DOWN:
 361                     layer_switch_on(code);
 362                     break;
 363                 case FN_UP:
 364                     layer_switch_off(code);
 365                     break;
 366                 case FNK_DOWN:
 367                     // repeat Fn alt key when press Fn key down, up then down again quickly
 368                     if (KEYEQ(delayed_fn.event.key, event.key) &&
 369                             timer_elapsed(delayed_fn.time) < LAYER_DELAY) {
 370                         register_code(code);
 371                         NEXT(PRESSING);
 372                     } else {
 373                         delayed_fn = (keyrecord_t) {
 374                             .event = event,
 375                             .code = code,
 376                             .mods = keyboard_report->mods,
 377                             .time = timer_read()
 378                         };
 379                         NEXT(DELAYING);
 380                     }
 381                     break;
 382                 case FNK_UP:
 383                     layer_switch_off(code);
 384                     break;
 385                 case KEY_DOWN:
 386                     register_code(code);
 387                     NEXT(PRESSING);
 388                     break;
 389                 case MOD_DOWN:
 390                     register_code(code);
 391                     break;
 392                 case KEY_UP:
 393                 case MOD_UP:
 394                     unregister_code(code);
 395                     break;
 396                 default:
 397                     break;
 398             }
 399             break;
 400         case PRESSING:
 401             switch (kind) {
 402                 case FN_DOWN:
 403                     // ignored when any key is pressed
 404                     break;
 405                 case FN_UP:
 406                     if (layer_switch_off(code))
 407                         NEXT(IDLE);
 408                     break;
 409                 case FNK_DOWN:
 410                     register_code(code);
 411                     break;
 412                 case FNK_UP:
 413                     if (layer_switch_off(code)) {
 414                         NEXT(IDLE);
 415                     } else {
 416                         unregister_code(code);
 417                         if (!anykey_sent_to_host())
 418                             NEXT(IDLE);
 419                     }
 420                     break;
 421                 case KEY_DOWN:
 422                 case MOD_DOWN:
 423                     register_code(code);
 424                     break;
 425                 case KEY_UP:
 426                 case MOD_UP:
 427                     unregister_code(code);
 428                     if (!anykey_sent_to_host())
 429                         NEXT(IDLE);
 430                     break;
 431                 default:
 432                     break;
 433             }
 434             break;
 435         case DELAYING:
 436             switch (kind) {
 437                 case FN_DOWN:
 438                 case FNK_DOWN:
 439                 case KEY_DOWN:
 440                     waiting_key = (keyrecord_t) {
 441                         .event = event,
 442                         .code = code,
 443                         .mods = keyboard_report->mods,
 444                         .time = timer_read()
 445                     };
 446                     NEXT(WAITING);
 447                     break;
 448                 case MOD_DOWN:
 449                     register_code(code);
 450                     break;
 451                 case FN_UP:
 452                     if (layer_switch_off(code))
 453                         NEXT(IDLE);
 454                     break;
 455                 case FNK_UP:
 456                     if (code == delayed_fn.code) {
 457                         // type Fn with alt keycode
 458                         // restore the mod status at the time of pressing Fn key
 459                         tmp_mods = keyboard_report->mods;
 460                         host_set_mods(delayed_fn.mods);
 461                         register_code(delayed_fn.code);
 462                         unregister_code(delayed_fn.code);
 463                         host_set_mods(tmp_mods);
 464                         NEXT(IDLE);
 465                     } else {
 466                         if (layer_switch_off(code))
 467                             NEXT(IDLE);
 468                     }
 469                     break;
 470                 case KEY_UP:
 471                 case MOD_UP:
 472                     unregister_code(code);
 473                     break;
 474                 default:
 475                     break;
 476             }
 477             break;
 478         case WAITING:
 479             switch (kind) {
 480                 case FN_DOWN:
 481                 case FNK_DOWN:
 482                 case KEY_DOWN:
 483                     tmp_mods = keyboard_report->mods;
 484                     host_set_mods(delayed_fn.mods);
 485                     register_code(delayed_fn.code);
 486                     host_set_mods(waiting_key.mods);
 487                     register_code(waiting_key.code);
 488                     host_set_mods(tmp_mods);
 489                     if (kind == FN_DOWN) {
 490                         // ignore Fn
 491                     } else if (kind == FNK_DOWN) {
 492                         register_code(code);
 493                     } else if (kind == KEY_DOWN) {
 494                         register_code(code);
 495                     }
 496                     NEXT(IDLE);
 497                     break;
 498                 case MOD_DOWN:
 499                     register_code(code);
 500                     break;
 501                 case FN_UP:
 502                     if (layer_switch_off(code))
 503                         NEXT(IDLE);
 504                     break;
 505                 case FNK_UP:
 506                     if (code == delayed_fn.code) {
 507                         // alt down, key down, alt up
 508                         tmp_mods = keyboard_report->mods;
 509                         host_set_mods(delayed_fn.mods);
 510                         register_code(delayed_fn.code);
 511                         host_set_mods(waiting_key.mods);
 512                         register_code(waiting_key.code);
 513                         unregister_code(delayed_fn.code);
 514                         host_set_mods(tmp_mods);
 515                         NEXT(IDLE);
 516                     } else {
 517                         if (layer_switch_off(code))
 518                             NEXT(IDLE);
 519                     }
 520                     break;
 521                 case KEY_UP:
 522                     if (code == waiting_key.code) {
 523                         layer_switch_on(delayed_fn.code);
 524                         NEXT(IDLE);
 525                         // process waiting_key
 526                         tmp_mods = keyboard_report->mods;
 527                         host_set_mods(waiting_key.mods);
 528                         process_key(waiting_key.event);
 529                         host_set_mods(tmp_mods);
 530                         process_key(event);
 531                     } else {
 532                         unregister_code(code);
 533                     }
 534                     break;
 535                 case MOD_UP:
 536                     unregister_code(code);
 537                     break;
 538                 default:
 539                     break;
 540             }
 541             break;
 542     }
 543 }
 544
 545 void keyboard_init(void)
 546 {
 547     // TODO: to enable debug print magic key bind on boot time
 548
 549     // TODO: configuration of sendchar impl
 550     print_sendchar_func = sendchar;
 551
 552     timer_init();
 553     matrix_init();
 554 #ifdef PS2_MOUSE_ENABLE
 555     ps2_mouse_init();
 556 #endif
 557 }
 558
 559 void keyboard_task(void)
 560 {
 561     static matrix_row_t matrix_prev[MATRIX_ROWS];
 562     static uint8_t led_status = 0;
 563     matrix_row_t matrix_row = 0;
 564     matrix_row_t matrix_change = 0;
 565
 566     matrix_scan();
 567     for (uint8_t r = 0; r < MATRIX_ROWS; r++) {
 568         matrix_row = matrix_get_row(r);
 569         matrix_change = matrix_row ^ matrix_prev[r];
 570         if (matrix_change) {
 571             if (debug_matrix) matrix_print();
 572
 573             for (uint8_t c = 0; c < MATRIX_COLS; c++) {
 574                 if (matrix_change & ((matrix_row_t)1<<c)) {
 575                     process_key((keyevent_t){
 576                         .key = (key_t){ .row = r, .col = c },
 577                         .pressed = (matrix_row & ((matrix_row_t)1<<c))
 578                     });
 579                     // record a processed key
 580                     matrix_prev[r] ^= ((matrix_row_t)1<<c);
 581                     // process a key per task call
 582                     goto MATRIX_LOOP_END;
 583                 }
 584             }
 585         }
 586     }
 587     MATRIX_LOOP_END:
 588
 589     // layer switch when delay term elapses
 590     if (kbdstate == DELAYING || kbdstate == WAITING) {
 591         if (timer_elapsed(delayed_fn.time) > LAYER_DELAY) {
 592             if (kbdstate == DELAYING) {
 593                 layer_switch_on(delayed_fn.code);
 594                 NEXT(IDLE);
 595             }
 596             if (kbdstate == WAITING) {
 597                 layer_switch_on(delayed_fn.code);
 598                 NEXT(IDLE);
 599                 uint8_t tmp_mods = keyboard_report->mods;
 600                 host_set_mods(waiting_key.mods);
 601                 process_key(waiting_key.event);
 602                 host_set_mods(tmp_mods);
 603             }
 604         }
 605     }
 606
 607 #ifdef MOUSEKEY_ENABLE
 608     // mousekey repeat & acceleration
 609     mousekey_task();
 610 #endif
 611
 612     // FAIL SAFE: clear all key if no key down
 613     if (matrix_change) {
 614         matrix_row_t is_matrix_on = 0;
 615         for (int r = 0; r < MATRIX_ROWS; r++) {
 616             is_matrix_on |= matrix_get_row(r);
 617         }
 618         if (!is_matrix_on) {
 619             Kdebug("FAIL SAFE: clear all keys(default layer).\n");
 620             clear_keyboard();
 621             current_layer = default_layer;
 622             fn_state_bits = 0;
 623             delayed_fn = (keyrecord_t){};
 624             waiting_key = (keyrecord_t){};
 625             NEXT(IDLE);
 626         }
 627     }
 628
 629     // update LED
 630     if (led_status != host_keyboard_leds()) {
 631         led_status = host_keyboard_leds();
 632         keyboard_set_leds(led_status);
 633     }
 634
 635     return;
 636 }
 637
 638 void keyboard_set_leds(uint8_t leds)
 639 {
 640     led_set(leds);
 641 }