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