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